Initial import

.gitignore

@@ -0,0 +1,4 @@
+build
+dist
+python_heatclient.egg-info
+*.log

LICENSE

@@ -0,0 +1,175 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.

MANIFEST.in

@@ -0,0 +1,5 @@
+include AUTHORS
+include ChangeLog
+include heatclient/versioninfo
+exclude .gitignore
+exclude .gitreview

README.rst

@@ -0,0 +1,12 @@
+Python bindings to the Heat orchestration API
+=============================================
+
+This is a client library for Heat built on the Heat orchestration API. It
+provides a Python API (the ``heatclient`` module) and a command-line tool
+(``heat``).
+
+Development takes place via the usual OpenStack processes as outlined in the
+`OpenStack wiki <http://wiki.openstack.org/HowToContribute>`_.  The master
+repository is on `GitHub <http://github.com/heat-api/python-heatclient>`_.
+
+See release notes and more at `<http://docs.openstack.org/developer/python-heatclient/>`_.

doc/source/conf.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+#
+
+import os
+import sys
+
+project = 'python-heatclient'
+
+# -- General configuration ----------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
+extensions = ['sphinx.ext.autodoc', 'sphinx.ext.intersphinx']
+
+# autodoc generation is a bit aggressive and a nuisance when doing heavy
+# text edit cycles.
+# execute "export SPHINX_DEBUG=1" in your terminal to disable
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix of source filenames.
+source_suffix = '.rst'
+
+# The master toctree document.
+master_doc = 'index'
+
+# General information about the project.
+copyright = u'OpenStack LLC'
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+add_module_names = True
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+# -- Options for HTML output --------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  Major themes that come with
+# Sphinx are currently 'default' and 'sphinxdoc'.
+html_theme = 'nature'
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = '%sdoc' % project
+
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title, author, documentclass
+# [howto/manual]).
+latex_documents = [
+    (
+        'index',
+        '%s.tex' % project,
+        u'%s Documentation' % project,
+        u'OpenStack LLC',
+        'manual'
+    ),
+]
+
+# Example configuration for intersphinx: refer to the Python standard library.
+intersphinx_mapping = {'http://docs.python.org/': None}

doc/source/index.rst

@@ -0,0 +1,32 @@
+Python API
+==========
+In order to use the python api directly, you must first obtain an auth token and identify which endpoint you wish to speak to. Once you have done so, you can use the API like so::
+
+    >>> from heatclient import Client
+    >>> heat = Client('1', endpoint=OS_IMAGE_ENDPOINT, token=OS_AUTH_TOKEN)
+...
+
+
+Command-line Tool
+=================
+In order to use the CLI, you must provide your OpenStack username, password, tenant, and auth endpoint. Use the corresponding configuration options (``--os-username``, ``--os-password``, ``--os-tenant-id``, and ``--os-auth-url``) or set them in environment variables::
+
+    export OS_USERNAME=user
+    export OS_PASSWORD=pass
+    export OS_TENANT_ID=b363706f891f48019483f8bd6503c54b
+    export OS_AUTH_URL=http://auth.example.com:5000/v2.0
+
+The command line tool will attempt to reauthenticate using your provided credentials for every request. You can override this behavior by manually supplying an auth token using ``--os-image-url`` and ``--os-auth-token``. You can alternatively set these environment variables::
+
+    export OS_IMAGE_URL=http://heat.example.org:8004/
+    export OS_AUTH_TOKEN=3bcc3d3a03f44e3d8377f9247b0ad155
+
+Once you've configured your authentication parameters, you can run ``heat help`` to see a complete listing of available commands.
+
+
+Release Notes
+=============
+
+0.1.0
+-----
+* Initial release

heatclient/__init__.py

@@ -0,0 +1,26 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+#NOTE(bcwaldon): this try/except block is needed to run setup.py due to
+# its need to import local code before installing required dependencies
+try:
+    import heatclient.client
+    Client = heatclient.client.Client
+except ImportError:
+    import warnings
+    warnings.warn("Could not import heatclient.client", ImportWarning)
+
+import heatclient.version
+
+__version__ = heatclient.version.version_info.deferred_version_string()

heatclient/client.py

@@ -0,0 +1,19 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from heatclient.common import utils
+
+
+def Client(version, *args, **kwargs):
+    module = utils.import_versioned_module(version, 'client')
+    client_class = getattr(module, 'Client')
+    return client_class(*args, **kwargs)

heatclient/common/base.py

@@ -0,0 +1,131 @@
+# Copyright 2012 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Base utilities to build API operation managers and objects on top of.
+"""
+
+import copy
+
+
+# Python 2.4 compat
+try:
+    all
+except NameError:
+    def all(iterable):
+        return True not in (not x for x in iterable)
+
+
+def getid(obj):
+    """
+    Abstracts the common pattern of allowing both an object or an object's ID
+    (UUID) as a parameter when dealing with relationships.
+    """
+    try:
+        return obj.id
+    except AttributeError:
+        return obj
+
+
+class Manager(object):
+    """
+    Managers interact with a particular type of API (servers, flavors, images,
+    etc.) and provide CRUD operations for them.
+    """
+    resource_class = None
+
+    def __init__(self, api):
+        self.api = api
+
+    def _list(self, url, response_key, obj_class=None, body=None):
+        resp, body = self.api.json_request('GET', url)
+
+        if obj_class is None:
+            obj_class = self.resource_class
+
+        data = body[response_key]
+        return [obj_class(self, res, loaded=True) for res in data if res]
+
+    def _delete(self, url):
+        self.api.raw_request('DELETE', url)
+
+    def _update(self, url, body, response_key=None):
+        resp, body = self.api.json_request('PUT', url, body=body)
+        # PUT requests may not return a body
+        if body:
+            return self.resource_class(self, body[response_key])
+
+
+class Resource(object):
+    """
+    A resource represents a particular instance of an object (tenant, user,
+    etc). This is pretty much just a bag for attributes.
+
+    :param manager: Manager object
+    :param info: dictionary representing resource attributes
+    :param loaded: prevent lazy-loading if set to True
+    """
+    def __init__(self, manager, info, loaded=False):
+        self.manager = manager
+        self._info = info
+        self._add_details(info)
+        self._loaded = loaded
+
+    def _add_details(self, info):
+        for (k, v) in info.iteritems():
+            setattr(self, k, v)
+
+    def __getattr__(self, k):
+        if k not in self.__dict__:
+            #NOTE(bcwaldon): disallow lazy-loading if already loaded once
+            if not self.is_loaded():
+                self.get()
+                return self.__getattr__(k)
+
+            raise AttributeError(k)
+        else:
+            return self.__dict__[k]
+
+    def __repr__(self):
+        reprkeys = sorted(k for k in self.__dict__.keys() if k[0] != '_' and
+                                                                k != 'manager')
+        info = ", ".join("%s=%s" % (k, getattr(self, k)) for k in reprkeys)
+        return "<%s %s>" % (self.__class__.__name__, info)
+
+    def get(self):
+        # set_loaded() first ... so if we have to bail, we know we tried.
+        self.set_loaded(True)
+        if not hasattr(self.manager, 'get'):
+            return
+
+        new = self.manager.get(self.id)
+        if new:
+            self._add_details(new._info)
+
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            return False
+        if hasattr(self, 'id') and hasattr(other, 'id'):
+            return self.id == other.id
+        return self._info == other._info
+
+    def is_loaded(self):
+        return self._loaded
+
+    def set_loaded(self, val):
+        self._loaded = val
+
+    def to_dict(self):
+        return copy.deepcopy(self._info)

heatclient/common/http.py

@@ -0,0 +1,276 @@
+# Copyright 2012 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import copy
+import httplib
+import logging
+import os
+import socket
+import StringIO
+import urlparse
+
+try:
+    import ssl
+except ImportError:
+    #TODO(bcwaldon): Handle this failure more gracefully
+    pass
+
+try:
+    import json
+except ImportError:
+    import simplejson as json
+
+# Python 2.5 compat fix
+if not hasattr(urlparse, 'parse_qsl'):
+    import cgi
+    urlparse.parse_qsl = cgi.parse_qsl
+
+
+from heatclient import exc
+
+
+LOG = logging.getLogger(__name__)
+USER_AGENT = 'python-heatclient'
+CHUNKSIZE = 1024 * 64  # 64kB
+
+
+class HTTPClient(object):
+
+    def __init__(self, endpoint, **kwargs):
+        self.endpoint = endpoint
+        self.auth_token = kwargs.get('token')
+        self.connection_params = self.get_connection_params(endpoint, **kwargs)
+
+    @staticmethod
+    def get_connection_params(endpoint, **kwargs):
+        parts = urlparse.urlparse(endpoint)
+
+        _args = (parts.hostname, parts.port, parts.path)
+        _kwargs = {'timeout': float(kwargs.get('timeout', 600))}
+
+        if parts.scheme == 'https':
+            _class = VerifiedHTTPSConnection
+            _kwargs['ca_file'] = kwargs.get('ca_file', None)
+            _kwargs['cert_file'] = kwargs.get('cert_file', None)
+            _kwargs['key_file'] = kwargs.get('key_file', None)
+            _kwargs['insecure'] = kwargs.get('insecure', False)
+        elif parts.scheme == 'http':
+            _class = httplib.HTTPConnection
+        else:
+            msg = 'Unsupported scheme: %s' % parts.scheme
+            raise exc.InvalidEndpoint(msg)
+
+        return (_class, _args, _kwargs)
+
+    def get_connection(self):
+        _class = self.connection_params[0]
+        try:
+            return _class(*self.connection_params[1],
+                          **self.connection_params[2])
+        except httplib.InvalidURL:
+            raise exc.InvalidEndpoint()
+
+    def log_curl_request(self, method, url, kwargs):
+        curl = ['curl -i -X %s' % method]
+
+        for (key, value) in kwargs['headers'].items():
+            header = '-H \'%s: %s\'' % (key, value)
+            curl.append(header)
+
+        conn_params_fmt = [
+            ('key_file', '--key %s'),
+            ('cert_file', '--cert %s'),
+            ('ca_file', '--cacert %s'),
+        ]
+        for (key, fmt) in conn_params_fmt:
+            value = self.connection_params[2].get(key)
+            if value:
+                curl.append(fmt % value)
+
+        if self.connection_params[2].get('insecure'):
+            curl.append('-k')
+
+        if 'body' in kwargs:
+            curl.append('-d \'%s\'' % kwargs['body'])
+
+        curl.append('%s%s' % (self.endpoint, url))
+        LOG.debug(' '.join(curl))
+
+    @staticmethod
+    def log_http_response(resp, body=None):
+        status = (resp.version / 10.0, resp.status, resp.reason)
+        dump = ['\nHTTP/%.1f %s %s' % status]
+        dump.extend(['%s: %s' % (k, v) for k, v in resp.getheaders()])
+        dump.append('')
+        if body:
+            dump.extend([body, ''])
+        LOG.debug('\n'.join(dump))
+
+    def _http_request(self, url, method, **kwargs):
+        """ Send an http request with the specified characteristics.
+
+        Wrapper around httplib.HTTP(S)Connection.request to handle tasks such
+        as setting headers and error handling.
+        """
+        # Copy the kwargs so we can reuse the original in case of redirects
+        kwargs['headers'] = copy.deepcopy(kwargs.get('headers', {}))
+        kwargs['headers'].setdefault('User-Agent', USER_AGENT)
+        if self.auth_token:
+            kwargs['headers'].setdefault('X-Auth-Token', self.auth_token)
+
+        self.log_curl_request(method, url, kwargs)
+        conn = self.get_connection()
+
+        try:
+            conn_params = self.connection_params[1][2]
+            conn_url = os.path.normpath('%s/%s' % (conn_params, url))
+            conn.request(method, conn_url, **kwargs)
+            resp = conn.getresponse()
+        except socket.gaierror as e:
+            message = "Error finding address for %(url)s: %(e)s" % locals()
+            raise exc.InvalidEndpoint(message=message)
+        except (socket.error, socket.timeout) as e:
+            endpoint = self.endpoint
+            message = "Error communicating with %(endpoint)s %(e)s" % locals()
+            raise exc.CommunicationError(message=message)
+
+        body_iter = ResponseBodyIterator(resp)
+
+        # Read body into string if it isn't obviously image data
+        if resp.getheader('content-type', None) != 'application/octet-stream':
+            body_str = ''.join([chunk for chunk in body_iter])
+            self.log_http_response(resp, body_str)
+            body_iter = StringIO.StringIO(body_str)
+        else:
+            self.log_http_response(resp)
+
+        if 400 <= resp.status < 600:
+            LOG.error("Request returned failure status.")
+            raise exc.from_response(resp)
+        elif resp.status in (301, 302, 305):
+            # Redirected. Reissue the request to the new location.
+            return self._http_request(resp['location'], method, **kwargs)
+        elif resp.status == 300:
+            raise exc.from_response(resp)
+
+        return resp, body_iter
+
+    def json_request(self, method, url, **kwargs):
+        kwargs.setdefault('headers', {})
+        kwargs['headers'].setdefault('Content-Type', 'application/json')
+        kwargs['headers'].setdefault('Accept', 'application/json')
+
+        if 'body' in kwargs:
+            kwargs['body'] = json.dumps(kwargs['body'])
+
+        resp, body_iter = self._http_request(url, method, **kwargs)
+
+        if 'application/json' in resp.getheader('content-type', None):
+            body = ''.join([chunk for chunk in body_iter])
+            try:
+                body = json.loads(body)
+            except ValueError:
+                LOG.error('Could not decode response body as JSON')
+        else:
+            body = None
+
+        return resp, body
+
+    def raw_request(self, method, url, **kwargs):
+        kwargs.setdefault('headers', {})
+        kwargs['headers'].setdefault('Content-Type',
+                                     'application/octet-stream')
+        return self._http_request(url, method, **kwargs)
+
+
+class VerifiedHTTPSConnection(httplib.HTTPSConnection):
+    """httplib-compatibile connection using client-side SSL authentication
+
+    :see http://code.activestate.com/recipes/
+            577548-https-httplib-client-connection-with-certificate-v/
+    """
+
+    def __init__(self, host, port, key_file=None, cert_file=None,
+                 ca_file=None, timeout=None, insecure=False):
+        httplib.HTTPSConnection.__init__(self, host, port, key_file=key_file,
+                                         cert_file=cert_file)
+        self.key_file = key_file
+        self.cert_file = cert_file
+        if ca_file is not None:
+            self.ca_file = ca_file
+        else:
+            self.ca_file = self.get_system_ca_file()
+        self.timeout = timeout
+        self.insecure = insecure
+
+    def connect(self):
+        """
+        Connect to a host on a given (SSL) port.
+        If ca_file is pointing somewhere, use it to check Server Certificate.
+
+        Redefined/copied and extended from httplib.py:1105 (Python 2.6.x).
+        This is needed to pass cert_reqs=ssl.CERT_REQUIRED as parameter to
+        ssl.wrap_socket(), which forces SSL to check server certificate against
+        our client certificate.
+        """
+        sock = socket.create_connection((self.host, self.port), self.timeout)
+
+        if self._tunnel_host:
+            self.sock = sock
+            self._tunnel()
+
+        if self.insecure is True:
+            kwargs = {'cert_reqs': ssl.CERT_NONE}
+        else:
+            kwargs = {'cert_reqs': ssl.CERT_REQUIRED, 'ca_certs': self.ca_file}
+
+        if self.cert_file:
+            kwargs['certfile'] = self.cert_file
+            if self.key_file:
+                kwargs['keyfile'] = self.key_file
+
+        self.sock = ssl.wrap_socket(sock, **kwargs)
+
+    @staticmethod
+    def get_system_ca_file():
+        """"Return path to system default CA file"""
+        # Standard CA file locations for Debian/Ubuntu, RedHat/Fedora,
+        # Suse, FreeBSD/OpenBSD
+        ca_path = ['/etc/ssl/certs/ca-certificates.crt',
+                   '/etc/pki/tls/certs/ca-bundle.crt',
+                   '/etc/ssl/ca-bundle.pem',
+                   '/etc/ssl/cert.pem']
+        for ca in ca_path:
+            if os.path.exists(ca):
+                return ca
+        return None
+
+
+class ResponseBodyIterator(object):
+    """A class that acts as an iterator over an HTTP response."""
+
+    def __init__(self, resp):
+        self.resp = resp
+
+    def __iter__(self):
+        while True:
+            yield self.next()
+
+    def next(self):
+        chunk = self.resp.read(CHUNKSIZE)
+        if chunk:
+            return chunk
+        else:
+            raise StopIteration()

heatclient/common/utils.py

@@ -0,0 +1,134 @@
+# Copyright 2012 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import errno
+import hashlib
+import os
+import sys
+import uuid
+
+import prettytable
+
+from heatclient import exc
+from heatclient.openstack.common import importutils
+
+
+# Decorator for cli-args
+def arg(*args, **kwargs):
+    def _decorator(func):
+        # Because of the sematics of decorator composition if we just append
+        # to the options list positional options will appear to be backwards.
+        func.__dict__.setdefault('arguments', []).insert(0, (args, kwargs))
+        return func
+    return _decorator
+
+
+def pretty_choice_list(l):
+    return ', '.join("'%s'" % i for i in l)
+
+
+def print_list(objs, fields, formatters={}):
+    pt = prettytable.PrettyTable([f for f in fields], caching=False)
+    pt.align = 'l'
+
+    for o in objs:
+        row = []
+        for field in fields:
+            if field in formatters:
+                row.append(formatters[field](o))
+            else:
+                field_name = field.lower().replace(' ', '_')
+                data = getattr(o, field_name, None) or ''
+                row.append(data)
+        pt.add_row(row)
+
+    print pt.get_string(sortby=fields[0])
+
+
+def print_dict(d):
+    pt = prettytable.PrettyTable(['Property', 'Value'], caching=False)
+    pt.align = 'l'
+    [pt.add_row(list(r)) for r in d.iteritems()]
+    print pt.get_string(sortby='Property')
+
+
+def find_resource(manager, name_or_id):
+    """Helper for the _find_* methods."""
+    # first try to get entity as integer id
+    try:
+        if isinstance(name_or_id, int) or name_or_id.isdigit():
+            return manager.get(int(name_or_id))
+    except exc.NotFound:
+        pass
+
+    # now try to get entity as uuid
+    try:
+        uuid.UUID(str(name_or_id))
+        return manager.get(name_or_id)
+    except (ValueError, exc.NotFound):
+        pass
+
+    # finally try to find entity by name
+    try:
+        return manager.find(name=name_or_id)
+    except exc.NotFound:
+        msg = "No %s with a name or ID of '%s' exists." % \
+              (manager.resource_class.__name__.lower(), name_or_id)
+        raise exc.CommandError(msg)
+
+
+def skip_authentication(f):
+    """Function decorator used to indicate a caller may be unauthenticated."""
+    f.require_authentication = False
+    return f
+
+
+def is_authentication_required(f):
+    """Checks to see if the function requires authentication.
+
+    Use the skip_authentication decorator to indicate a caller may
+    skip the authentication step.
+    """
+    return getattr(f, 'require_authentication', True)
+
+
+def string_to_bool(arg):
+    return arg.strip().lower() in ('t', 'true', 'yes', '1')
+
+
+def env(*vars, **kwargs):
+    """Search for the first defined of possibly many env vars
+
+    Returns the first environment variable defined in vars, or
+    returns the default defined in kwargs.
+    """
+    for v in vars:
+        value = os.environ.get(v, None)
+        if value:
+            return value
+    return kwargs.get('default', '')
+
+
+def import_versioned_module(version, submodule=None):
+    module = 'heatclient.v%s' % version
+    if submodule:
+        module = '.'.join((module, submodule))
+    return importutils.import_module(module)
+
+
+def exit(msg=''):
+    if msg:
+        print >> sys.stderr, msg
+    sys.exit(1)

heatclient/exc.py

@@ -0,0 +1,163 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import sys
+
+
+class BaseException(Exception):
+    """An error occurred."""
+    def __init__(self, message=None):
+        self.message = message
+
+    def __str__(self):
+        return self.message or self.__class__.__doc__
+
+
+class CommandError(BaseException):
+    """Invalid usage of CLI"""
+
+
+class InvalidEndpoint(BaseException):
+    """The provided endpoint is invalid."""
+
+
+class CommunicationError(BaseException):
+    """Unable to communicate with server."""
+
+
+class ClientException(Exception):
+    """DEPRECATED"""
+
+
+class HTTPException(ClientException):
+    """Base exception for all HTTP-derived exceptions"""
+    code = 'N/A'
+
+    def __init__(self, details=None):
+        self.details = details
+
+    def __str__(self):
+        return "%s (HTTP %s)" % (self.__class__.__name__, self.code)
+
+
+class HTTPMultipleChoices(HTTPException):
+    code = 300
+
+    def __str__(self):
+        self.details = ("Requested version of OpenStack Images API is not"
+                        "available.")
+        return "%s (HTTP %s) %s" % (self.__class__.__name__, self.code,
+                                    self.details)
+
+
+class BadRequest(HTTPException):
+    """DEPRECATED"""
+    code = 400
+
+
+class HTTPBadRequest(BadRequest):
+    pass
+
+
+class Unauthorized(HTTPException):
+    """DEPRECATED"""
+    code = 401
+
+
+class HTTPUnauthorized(Unauthorized):
+    pass
+
+
+class Forbidden(HTTPException):
+    """DEPRECATED"""
+    code = 403
+
+
+class HTTPForbidden(Forbidden):
+    pass
+
+
+class NotFound(HTTPException):
+    """DEPRECATED"""
+    code = 404
+
+
+class HTTPNotFound(NotFound):
+    pass
+
+
+class HTTPMethodNotAllowed(HTTPException):
+    code = 405
+
+
+class Conflict(HTTPException):
+    """DEPRECATED"""
+    code = 409
+
+
+class HTTPConflict(Conflict):
+    pass
+
+
+class OverLimit(HTTPException):
+    """DEPRECATED"""
+    code = 413
+
+
+class HTTPOverLimit(OverLimit):
+    pass
+
+
+class HTTPInternalServerError(HTTPException):
+    code = 500
+
+
+class HTTPNotImplemented(HTTPException):
+    code = 501
+
+
+class HTTPBadGateway(HTTPException):
+    code = 502
+
+
+class ServiceUnavailable(HTTPException):
+    """DEPRECATED"""
+    code = 503
+
+
+class HTTPServiceUnavailable(ServiceUnavailable):
+    pass
+
+
+#NOTE(bcwaldon): Build a mapping of HTTP codes to corresponding exception
+# classes
+_code_map = {}
+for obj_name in dir(sys.modules[__name__]):
+    if obj_name.startswith('HTTP'):
+        obj = getattr(sys.modules[__name__], obj_name)
+        _code_map[obj.code] = obj
+
+
+def from_response(response):
+    """Return an instance of an HTTPException based on httplib response."""
+    cls = _code_map.get(response.status, HTTPException)
+    return cls()
+
+
+class NoTokenLookupException(Exception):
+    """DEPRECATED"""
+    pass
+
+
+class EndpointNotFound(Exception):
+    """DEPRECATED"""
+    pass

heatclient/exceptions.py

@@ -0,0 +1,166 @@
+# Copyright 2010 Jacob Kaplan-Moss
+"""
+Exception definitions.
+"""
+
+
+class UnsupportedVersion(Exception):
+    """Indicates that the user is trying to use an unsupported
+    version of the API"""
+    pass
+
+
+class CommandError(Exception):
+    pass
+
+
+class AuthorizationFailure(Exception):
+    pass
+
+
+class NoUniqueMatch(Exception):
+    pass
+
+
+class AuthSystemNotFound(Exception):
+    """When the user specify a AuthSystem but not installed."""
+    def __init__(self, auth_system):
+        self.auth_system = auth_system
+
+    def __str__(self):
+        return "AuthSystemNotFound: %s" % repr(self.auth_system)
+
+
+class NoTokenLookupException(Exception):
+    """This form of authentication does not support looking up
+       endpoints from an existing token."""
+    pass
+
+
+class EndpointNotFound(Exception):
+    """Could not find Service or Region in Service Catalog."""
+    pass
+
+
+class AmbiguousEndpoints(Exception):
+    """Found more than one matching endpoint in Service Catalog."""
+    def __init__(self, endpoints=None):
+        self.endpoints = endpoints
+
+    def __str__(self):
+        return "AmbiguousEndpoints: %s" % repr(self.endpoints)
+
+
+class ConnectionRefused(Exception):
+    """
+    Connection refused: the server refused the connection.
+    """
+    def __init__(self, response=None):
+        self.response = response
+
+    def __str__(self):
+        return "ConnectionRefused: %s" % repr(self.response)
+
+
+class ClientException(Exception):
+    """
+    The base exception class for all exceptions this library raises.
+    """
+    def __init__(self, code, message=None, details=None, request_id=None):
+        self.code = code
+        self.message = message or self.__class__.message
+        self.details = details
+        self.request_id = request_id
+
+    def __str__(self):
+        formatted_string = "%s (HTTP %s)" % (self.message, self.code)
+        if self.request_id:
+            formatted_string += " (Request-ID: %s)" % self.request_id
+
+        return formatted_string
+
+
+class BadRequest(ClientException):
+    """
+    HTTP 400 - Bad request: you sent some malformed data.
+    """
+    http_status = 400
+    message = "Bad request"
+
+
+class Unauthorized(ClientException):
+    """
+    HTTP 401 - Unauthorized: bad credentials.
+    """
+    http_status = 401
+    message = "Unauthorized"
+
+
+class Forbidden(ClientException):
+    """
+    HTTP 403 - Forbidden: your credentials don't give you access to this
+    resource.
+    """
+    http_status = 403
+    message = "Forbidden"
+
+
+class NotFound(ClientException):
+    """
+    HTTP 404 - Not found
+    """
+    http_status = 404
+    message = "Not found"
+
+
+class OverLimit(ClientException):
+    """
+    HTTP 413 - Over limit: you're over the API limits for this time period.
+    """
+    http_status = 413
+    message = "Over limit"
+
+
+# NotImplemented is a python keyword.
+class HTTPNotImplemented(ClientException):
+    """
+    HTTP 501 - Not Implemented: the server does not support this operation.
+    """
+    http_status = 501
+    message = "Not Implemented"
+
+
+# In Python 2.4 Exception is old-style and thus doesn't have a __subclasses__()
+# so we can do this:
+#     _code_map = dict((c.http_status, c)
+#                      for c in ClientException.__subclasses__())
+#
+# Instead, we have to hardcode it:
+_code_map = dict((c.http_status, c) for c in [BadRequest, Unauthorized,
+                   Forbidden, NotFound, OverLimit, HTTPNotImplemented])
+
+
+def from_response(response, body):
+    """
+    Return an instance of an ClientException or subclass
+    based on an httplib2 response.
+
+    Usage::
+
+        resp, body = http.request(...)
+        if resp.status != 200:
+            raise exception_from_response(resp, body)
+    """
+    cls = _code_map.get(response.status, ClientException)
+    request_id = response.get('x-compute-request-id')
+    if body:
+        message = "n/a"
+        details = "n/a"
+        if hasattr(body, 'keys'):
+            error = body[body.keys()[0]]
+            message = error.get('message', None)
+            details = error.get('details', None)
+        return cls(code=response.status, message=message, details=details,
+                   request_id=request_id)
+    else:
+        return cls(code=response.status, request_id=request_id)

heatclient/openstack/common/importutils.py

@@ -0,0 +1,59 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Import related utilities and helper functions.
+"""
+
+import sys
+import traceback
+
+
+def import_class(import_str):
+    """Returns a class from a string including module and class"""
+    mod_str, _sep, class_str = import_str.rpartition('.')
+    try:
+        __import__(mod_str)
+        return getattr(sys.modules[mod_str], class_str)
+    except (ValueError, AttributeError), exc:
+        raise ImportError('Class %s cannot be found (%s)' %
+                          (class_str,
+                           traceback.format_exception(*sys.exc_info())))
+
+
+def import_object(import_str, *args, **kwargs):
+    """Import a class and return an instance of it."""
+    return import_class(import_str)(*args, **kwargs)
+
+
+def import_object_ns(name_space, import_str, *args, **kwargs):
+    """
+    Import a class and return an instance of it, first by trying
+    to find the class in a default namespace, then failing back to
+    a full path if not found in the default namespace.
+    """
+    import_value = "%s.%s" % (name_space, import_str)
+    try:
+        return import_class(import_value)(*args, **kwargs)
+    except ImportError:
+        return import_class(import_str)(*args, **kwargs)
+
+
+def import_module(import_str):
+    """Import a module."""
+    __import__(import_str)
+    return sys.modules[import_str]

heatclient/openstack/common/setup.py

@@ -0,0 +1,358 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Utilities with minimum-depends for use in setup.py
+"""
+
+import datetime
+import os
+import re
+import subprocess
+import sys
+
+from setuptools.command import sdist
+
+
+def parse_mailmap(mailmap='.mailmap'):
+    mapping = {}
+    if os.path.exists(mailmap):
+        fp = open(mailmap, 'r')
+        for l in fp:
+            l = l.strip()
+            if not l.startswith('#') and ' ' in l:
+                canonical_email, alias = [x for x in l.split(' ')
+                                          if x.startswith('<')]
+                mapping[alias] = canonical_email
+    return mapping
+
+
+def canonicalize_emails(changelog, mapping):
+    """Takes in a string and an email alias mapping and replaces all
+       instances of the aliases in the string with their real email.
+    """
+    for alias, email in mapping.iteritems():
+        changelog = changelog.replace(alias, email)
+    return changelog
+
+
+# Get requirements from the first file that exists
+def get_reqs_from_files(requirements_files):
+    for requirements_file in requirements_files:
+        if os.path.exists(requirements_file):
+            return open(requirements_file, 'r').read().split('\n')
+    return []
+
+
+def parse_requirements(requirements_files=['requirements.txt',
+                                           'tools/pip-requires']):
+    requirements = []
+    for line in get_reqs_from_files(requirements_files):
+        # For the requirements list, we need to inject only the portion
+        # after egg= so that distutils knows the package it's looking for
+        # such as:
+        # -e git://github.com/openstack/nova/master#egg=nova
+        if re.match(r'\s*-e\s+', line):
+            requirements.append(re.sub(r'\s*-e\s+.*#egg=(.*)$', r'\1',
+                                line))
+        # such as:
+        # http://github.com/openstack/nova/zipball/master#egg=nova
+        elif re.match(r'\s*https?:', line):
+            requirements.append(re.sub(r'\s*https?:.*#egg=(.*)$', r'\1',
+                                line))
+        # -f lines are for index locations, and don't get used here
+        elif re.match(r'\s*-f\s+', line):
+            pass
+        # argparse is part of the standard library starting with 2.7
+        # adding it to the requirements list screws distro installs
+        elif line == 'argparse' and sys.version_info >= (2, 7):
+            pass
+        else:
+            requirements.append(line)
+
+    return requirements
+
+
+def parse_dependency_links(requirements_files=['requirements.txt',
+                                               'tools/pip-requires']):
+    dependency_links = []
+    # dependency_links inject alternate locations to find packages listed
+    # in requirements
+    for line in get_reqs_from_files(requirements_files):
+        # skip comments and blank lines
+        if re.match(r'(\s*#)|(\s*$)', line):
+            continue
+        # lines with -e or -f need the whole line, minus the flag
+        if re.match(r'\s*-[ef]\s+', line):
+            dependency_links.append(re.sub(r'\s*-[ef]\s+', '', line))
+        # lines that are only urls can go in unmolested
+        elif re.match(r'\s*https?:', line):
+            dependency_links.append(line)
+    return dependency_links
+
+
+def write_requirements():
+    venv = os.environ.get('VIRTUAL_ENV', None)
+    if venv is not None:
+        with open("requirements.txt", "w") as req_file:
+            output = subprocess.Popen(["pip", "-E", venv, "freeze", "-l"],
+                                      stdout=subprocess.PIPE)
+            requirements = output.communicate()[0].strip()
+            req_file.write(requirements)
+
+
+def _run_shell_command(cmd):
+    output = subprocess.Popen(["/bin/sh", "-c", cmd],
+                              stdout=subprocess.PIPE)
+    out = output.communicate()
+    if len(out) == 0:
+        return None
+    if len(out[0].strip()) == 0:
+        return None
+    return out[0].strip()
+
+
+def _get_git_next_version_suffix(branch_name):
+    datestamp = datetime.datetime.now().strftime('%Y%m%d')
+    if branch_name == 'milestone-proposed':
+        revno_prefix = "r"
+    else:
+        revno_prefix = ""
+    _run_shell_command("git fetch origin +refs/meta/*:refs/remotes/meta/*")
+    milestone_cmd = "git show meta/openstack/release:%s" % branch_name
+    milestonever = _run_shell_command(milestone_cmd)
+    if not milestonever:
+        milestonever = ""
+    post_version = _get_git_post_version()
+    # post version should look like:
+    # 0.1.1.4.gcc9e28a
+    # where the bit after the last . is the short sha, and the bit between
+    # the last and second to last is the revno count
+    (revno, sha) = post_version.split(".")[-2:]
+    first_half = "%s~%s" % (milestonever, datestamp)
+    second_half = "%s%s.%s" % (revno_prefix, revno, sha)
+    return ".".join((first_half, second_half))
+
+
+def _get_git_current_tag():
+    return _run_shell_command("git tag --contains HEAD")
+
+
+def _get_git_tag_info():
+    return _run_shell_command("git describe --tags")
+
+
+def _get_git_post_version():
+    current_tag = _get_git_current_tag()
+    if current_tag is not None:
+        return current_tag
+    else:
+        tag_info = _get_git_tag_info()
+        if tag_info is None:
+            base_version = "0.0"
+            cmd = "git --no-pager log --oneline"
+            out = _run_shell_command(cmd)
+            revno = len(out.split("\n"))
+            sha = _run_shell_command("git describe --always")
+        else:
+            tag_infos = tag_info.split("-")
+            base_version = "-".join(tag_infos[:-2])
+            (revno, sha) = tag_infos[-2:]
+        return "%s.%s.%s" % (base_version, revno, sha)
+
+
+def write_git_changelog():
+    """Write a changelog based on the git changelog."""
+    new_changelog = 'ChangeLog'
+    if not os.getenv('SKIP_WRITE_GIT_CHANGELOG'):
+        if os.path.isdir('.git'):
+            git_log_cmd = 'git log --stat'
+            changelog = _run_shell_command(git_log_cmd)
+            mailmap = parse_mailmap()
+            with open(new_changelog, "w") as changelog_file:
+                changelog_file.write(canonicalize_emails(changelog, mailmap))
+    else:
+        open(new_changelog, 'w').close()
+
+
+def generate_authors():
+    """Create AUTHORS file using git commits."""
+    jenkins_email = 'jenkins@review.(openstack|stackforge).org'
+    old_authors = 'AUTHORS.in'
+    new_authors = 'AUTHORS'
+    if not os.getenv('SKIP_GENERATE_AUTHORS'):
+        if os.path.isdir('.git'):
+            # don't include jenkins email address in AUTHORS file
+            git_log_cmd = ("git log --format='%aN <%aE>' | sort -u | "
+                           "egrep -v '" + jenkins_email + "'")
+            changelog = _run_shell_command(git_log_cmd)
+            mailmap = parse_mailmap()
+            with open(new_authors, 'w') as new_authors_fh:
+                new_authors_fh.write(canonicalize_emails(changelog, mailmap))
+                if os.path.exists(old_authors):
+                    with open(old_authors, "r") as old_authors_fh:
+                        new_authors_fh.write('\n' + old_authors_fh.read())
+    else:
+        open(new_authors, 'w').close()
+
+
+_rst_template = """%(heading)s
+%(underline)s
+
+.. automodule:: %(module)s
+  :members:
+  :undoc-members:
+  :show-inheritance:
+"""
+
+
+def read_versioninfo(project):
+    """Read the versioninfo file. If it doesn't exist, we're in a github
+       zipball, and there's really no way to know what version we really
+       are, but that should be ok, because the utility of that should be
+       just about nil if this code path is in use in the first place."""
+    versioninfo_path = os.path.join(project, 'versioninfo')
+    if os.path.exists(versioninfo_path):
+        with open(versioninfo_path, 'r') as vinfo:
+            version = vinfo.read().strip()
+    else:
+        version = "0.0.0"
+    return version
+
+
+def write_versioninfo(project, version):
+    """Write a simple file containing the version of the package."""
+    open(os.path.join(project, 'versioninfo'), 'w').write("%s\n" % version)
+
+
+def get_cmdclass():
+    """Return dict of commands to run from setup.py."""
+
+    cmdclass = dict()
+
+    def _find_modules(arg, dirname, files):
+        for filename in files:
+            if filename.endswith('.py') and filename != '__init__.py':
+                arg["%s.%s" % (dirname.replace('/', '.'),
+                               filename[:-3])] = True
+
+    class LocalSDist(sdist.sdist):
+        """Builds the ChangeLog and Authors files from VC first."""
+
+        def run(self):
+            write_git_changelog()
+            generate_authors()
+            # sdist.sdist is an old style class, can't use super()
+            sdist.sdist.run(self)
+
+    cmdclass['sdist'] = LocalSDist
+
+    # If Sphinx is installed on the box running setup.py,
+    # enable setup.py to build the documentation, otherwise,
+    # just ignore it
+    try:
+        from sphinx.setup_command import BuildDoc
+
+        class LocalBuildDoc(BuildDoc):
+            def generate_autoindex(self):
+                print "**Autodocumenting from %s" % os.path.abspath(os.curdir)
+                modules = {}
+                option_dict = self.distribution.get_option_dict('build_sphinx')
+                source_dir = os.path.join(option_dict['source_dir'][1], 'api')
+                if not os.path.exists(source_dir):
+                    os.makedirs(source_dir)
+                for pkg in self.distribution.packages:
+                    if '.' not in pkg:
+                        os.path.walk(pkg, _find_modules, modules)
+                module_list = modules.keys()
+                module_list.sort()
+                autoindex_filename = os.path.join(source_dir, 'autoindex.rst')
+                with open(autoindex_filename, 'w') as autoindex:
+                    autoindex.write(""".. toctree::
+   :maxdepth: 1
+
+""")
+                    for module in module_list:
+                        output_filename = os.path.join(source_dir,
+                                                       "%s.rst" % module)
+                        heading = "The :mod:`%s` Module" % module
+                        underline = "=" * len(heading)
+                        values = dict(module=module, heading=heading,
+                                      underline=underline)
+
+                        print "Generating %s" % output_filename
+                        with open(output_filename, 'w') as output_file:
+                            output_file.write(_rst_template % values)
+                        autoindex.write("   %s.rst\n" % module)
+
+            def run(self):
+                if not os.getenv('SPHINX_DEBUG'):
+                    self.generate_autoindex()
+
+                for builder in ['html', 'man']:
+                    self.builder = builder
+                    self.finalize_options()
+                    self.project = self.distribution.get_name()
+                    self.version = self.distribution.get_version()
+                    self.release = self.distribution.get_version()
+                    BuildDoc.run(self)
+        cmdclass['build_sphinx'] = LocalBuildDoc
+    except ImportError:
+        pass
+
+    return cmdclass
+
+
+def get_git_branchname():
+    for branch in _run_shell_command("git branch --color=never").split("\n"):
+        if branch.startswith('*'):
+            _branch_name = branch.split()[1].strip()
+    if _branch_name == "(no":
+        _branch_name = "no-branch"
+    return _branch_name
+
+
+def get_pre_version(projectname, base_version):
+    """Return a version which is leading up to a version that will
+       be released in the future."""
+    if os.path.isdir('.git'):
+        current_tag = _get_git_current_tag()
+        if current_tag is not None:
+            version = current_tag
+        else:
+            branch_name = os.getenv('BRANCHNAME',
+                                    os.getenv('GERRIT_REFNAME',
+                                              get_git_branchname()))
+            version_suffix = _get_git_next_version_suffix(branch_name)
+            version = "%s~%s" % (base_version, version_suffix)
+        write_versioninfo(projectname, version)
+        return version
+    else:
+        version = read_versioninfo(projectname)
+    return version
+
+
+def get_post_version(projectname):
+    """Return a version which is equal to the tag that's on the current
+    revision if there is one, or tag plus number of additional revisions
+    if the current revision has no tag."""
+
+    if os.path.isdir('.git'):
+        version = _get_git_post_version()
+        write_versioninfo(projectname, version)
+        return version
+    return read_versioninfo(projectname)

heatclient/openstack/common/version.py

@@ -0,0 +1,148 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+#    Copyright 2012 OpenStack LLC
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Utilities for consuming the auto-generated versioninfo files.
+"""
+
+import datetime
+import pkg_resources
+
+import setup
+
+
+class _deferred_version_string(object):
+    """Internal helper class which provides delayed version calculation."""
+    def __init__(self, version_info, prefix):
+        self.version_info = version_info
+        self.prefix = prefix
+
+    def __str__(self):
+        return "%s%s" % (self.prefix, self.version_info.version_string())
+
+    def __repr__(self):
+        return "%s%s" % (self.prefix, self.version_info.version_string())
+
+
+class VersionInfo(object):
+
+    def __init__(self, package, python_package=None, pre_version=None):
+        """Object that understands versioning for a package
+        :param package: name of the top level python namespace. For heat,
+                        this would be "heat" for python-heatclient, it
+                        would be "heatclient"
+        :param python_package: optional name of the project name. For
+                               heat this can be left unset. For
+                               python-heatclient, this would be
+                               "python-heatclient"
+        :param pre_version: optional version that the project is working to
+        """
+        self.package = package
+        if python_package is None:
+            self.python_package = package
+        else:
+            self.python_package = python_package
+        self.pre_version = pre_version
+        self.version = None
+
+    def _generate_version(self):
+        """Defer to the openstack.common.setup routines for making a
+        version from git."""
+        if self.pre_version is None:
+            return setup.get_post_version(self.python_package)
+        else:
+            return setup.get_pre_version(self.python_package, self.pre_version)
+
+    def _newer_version(self, pending_version):
+        """Check to see if we're working with a stale version or not.
+        We expect a version string that either looks like:
+          2012.2~f3~20120708.10.4426392
+        which is an unreleased version of a pre-version, or:
+          0.1.1.4.gcc9e28a
+        which is an unreleased version of a post-version, or:
+          0.1.1
+        Which is a release and which should match tag.
+        For now, if we have a date-embedded version, check to see if it's
+        old, and if so re-generate. Otherwise, just deal with it.
+        """
+        try:
+            version_date = int(self.version.split("~")[-1].split('.')[0])
+            if version_date < int(datetime.date.today().strftime('%Y%m%d')):
+                return self._generate_version()
+            else:
+                return pending_version
+        except Exception:
+            return pending_version
+
+    def version_string_with_vcs(self, always=False):
+        """Return the full version of the package including suffixes indicating
+        VCS status.
+
+        For instance, if we are working towards the 2012.2 release,
+        canonical_version_string should return 2012.2 if this is a final
+        release, or else something like 2012.2~f1~20120705.20 if it's not.
+
+        :param always: if true, skip all version caching
+        """
+        if always:
+            self.version = self._generate_version()
+
+        if self.version is None:
+
+            requirement = pkg_resources.Requirement.parse(self.python_package)
+            versioninfo = "%s/versioninfo" % self.package
+            try:
+                raw_version = pkg_resources.resource_string(requirement,
+                                                            versioninfo)
+                self.version = self._newer_version(raw_version.strip())
+            except (IOError, pkg_resources.DistributionNotFound):
+                self.version = self._generate_version()
+
+        return self.version
+
+    def canonical_version_string(self, always=False):
+        """Return the simple version of the package excluding any suffixes.
+
+        For instance, if we are working towards the 2012.2 release,
+        canonical_version_string should return 2012.2 in all cases.
+
+        :param always: if true, skip all version caching
+        """
+        return self.version_string_with_vcs(always).split('~')[0]
+
+    def version_string(self, always=False):
+        """Return the base version of the package.
+
+        For instance, if we are working towards the 2012.2 release,
+        version_string should return 2012.2 if this is a final release, or
+        2012.2-dev if it is not.
+
+        :param always: if true, skip all version caching
+        """
+        version_parts = self.version_string_with_vcs(always).split('~')
+        if len(version_parts) == 1:
+            return version_parts[0]
+        else:
+            return '%s-dev' % (version_parts[0],)
+
+    def deferred_version_string(self, prefix=""):
+        """Generate an object which will expand in a string context to
+        the results of version_string(). We do this so that don't
+        call into pkg_resources every time we start up a program when
+        passing version information into the CONF constructor, but
+        rather only do the calculation when and if a version is requested
+        """
+        return _deferred_version_string(self, prefix)

heatclient/shell.py

@@ -0,0 +1,348 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Command-line interface to the OpenStack Images API.
+"""
+
+import argparse
+import logging
+import re
+import sys
+
+from keystoneclient.v2_0 import client as ksclient
+
+from heatclient import exc
+from heatclient import client as heatclient
+from heatclient.common import utils
+
+
+class HeatShell(object):
+
+    def get_base_parser(self):
+        parser = argparse.ArgumentParser(
+            prog='heat',
+            description=__doc__.strip(),
+            epilog='See "heat help COMMAND" '
+                   'for help on a specific command.',
+            add_help=False,
+            formatter_class=HelpFormatter,
+        )
+
+        # Global arguments
+        parser.add_argument('-h', '--help',
+            action='store_true',
+            help=argparse.SUPPRESS,
+        )
+
+        parser.add_argument('-d', '--debug',
+            default=bool(utils.env('HEATCLIENT_DEBUG')),
+            action='store_true',
+            help='Defaults to env[HEATCLIENT_DEBUG]')
+
+        parser.add_argument('-v', '--verbose',
+            default=False, action="store_true",
+            help="Print more verbose output")
+
+        parser.add_argument('-k', '--insecure',
+            default=False,
+            action='store_true',
+            help="Explicitly allow glanceclient to perform \"insecure\" "
+                 "SSL (https) requests. The server's certificate will "
+                 "not be verified against any certificate authorities. "
+                 "This option should be used with caution.")
+
+        parser.add_argument('--cert-file',
+            help='Path of certificate file to use in SSL connection. This '
+                 'file can optionally be prepended with the private key.')
+
+        parser.add_argument('--key-file',
+            help='Path of client key to use in SSL connection. This option is '
+                 'not necessary if your key is prepended to your cert file.')
+
+        parser.add_argument('--ca-file',
+            help='Path of CA SSL certificate(s) used to verify the remote '
+                 'server\'s certificate. Without this option glance looks '
+                 'for the default system CA certificates.')
+
+        parser.add_argument('--timeout',
+            default=600,
+            help='Number of seconds to wait for a response')
+
+        parser.add_argument('--os-username',
+            default=utils.env('OS_USERNAME'),
+            help='Defaults to env[OS_USERNAME]')
+
+        parser.add_argument('--os_username',
+            help=argparse.SUPPRESS)
+
+        parser.add_argument('--os-password',
+            default=utils.env('OS_PASSWORD'),
+            help='Defaults to env[OS_PASSWORD]')
+
+        parser.add_argument('--os_password',
+            help=argparse.SUPPRESS)
+
+        parser.add_argument('--os-tenant-id',
+            default=utils.env('OS_TENANT_ID'),
+            help='Defaults to env[OS_TENANT_ID]')
+
+        parser.add_argument('--os_tenant_id',
+            help=argparse.SUPPRESS)
+
+        parser.add_argument('--os-tenant-name',
+            default=utils.env('OS_TENANT_NAME'),
+            help='Defaults to env[OS_TENANT_NAME]')
+
+        parser.add_argument('--os_tenant_name',
+            help=argparse.SUPPRESS)
+
+        parser.add_argument('--os-auth-url',
+            default=utils.env('OS_AUTH_URL'),
+            help='Defaults to env[OS_AUTH_URL]')
+
+        parser.add_argument('--os_auth_url',
+            help=argparse.SUPPRESS)
+
+        parser.add_argument('--os-region-name',
+            default=utils.env('OS_REGION_NAME'),
+            help='Defaults to env[OS_REGION_NAME]')
+
+        parser.add_argument('--os_region_name',
+            help=argparse.SUPPRESS)
+
+        parser.add_argument('--os-auth-token',
+            default=utils.env('OS_AUTH_TOKEN'),
+            help='Defaults to env[OS_AUTH_TOKEN]')
+
+        parser.add_argument('--os_auth_token',
+            help=argparse.SUPPRESS)
+
+        parser.add_argument('--heat-url',
+            default=utils.env('HEAT_URL'),
+            help='Defaults to env[HEAT_URL]')
+
+        parser.add_argument('--heat_url',
+            help=argparse.SUPPRESS)
+
+        parser.add_argument('--heat-api-version',
+            default=utils.env('HEAT_API_VERSION', default='1'),
+            help='Defaults to env[HEAT_API_VERSION] or 1')
+
+        parser.add_argument('--heat_api_version',
+            help=argparse.SUPPRESS)
+
+        parser.add_argument('--os-service-type',
+            default=utils.env('OS_SERVICE_TYPE'),
+            help='Defaults to env[OS_SERVICE_TYPE]')
+
+        parser.add_argument('--os_service_type',
+            help=argparse.SUPPRESS)
+
+        parser.add_argument('--os-endpoint-type',
+            default=utils.env('OS_ENDPOINT_TYPE'),
+            help='Defaults to env[OS_ENDPOINT_TYPE]')
+
+        parser.add_argument('--os_endpoint_type',
+            help=argparse.SUPPRESS)
+
+        return parser
+
+    def get_subcommand_parser(self, version):
+        parser = self.get_base_parser()
+
+        self.subcommands = {}
+        subparsers = parser.add_subparsers(metavar='<subcommand>')
+        submodule = utils.import_versioned_module(version, 'shell')
+        self._find_actions(subparsers, submodule)
+        self._find_actions(subparsers, self)
+
+        return parser
+
+    def _find_actions(self, subparsers, actions_module):
+        for attr in (a for a in dir(actions_module) if a.startswith('do_')):
+            # I prefer to be hypen-separated instead of underscores.
+            command = attr[3:].replace('_', '-')
+            callback = getattr(actions_module, attr)
+            desc = callback.__doc__ or ''
+            help = desc.strip().split('\n')[0]
+            arguments = getattr(callback, 'arguments', [])
+
+            subparser = subparsers.add_parser(command,
+                help=help,
+                description=desc,
+                add_help=False,
+                formatter_class=HelpFormatter
+            )
+            subparser.add_argument('-h', '--help',
+                action='help',
+                help=argparse.SUPPRESS,
+            )
+            self.subcommands[command] = subparser
+            for (args, kwargs) in arguments:
+                subparser.add_argument(*args, **kwargs)
+            subparser.set_defaults(func=callback)
+
+    # TODO(dtroyer): move this into the common client support?
+    # Compatibility check to remove API version as the trailing component
+    # in a service endpoint; also removes a trailing '/'
+    def _strip_version(self, endpoint):
+        """Strip a version from the last component of an endpoint if present"""
+
+        # Get rid of trailing '/' if present
+        if endpoint.endswith('/'):
+            endpoint = endpoint[:-1]
+        url_bits = endpoint.split('/')
+        # regex to match 'v1' or 'v2.0' etc
+        if re.match('v\d+\.?\d*', url_bits[-1]):
+            endpoint = '/'.join(url_bits[:-1])
+        return endpoint
+
+    def _get_ksclient(self, **kwargs):
+        """Get an endpoint and auth token from Keystone.
+
+        :param username: name of user
+        :param password: user's password
+        :param tenant_id: unique identifier of tenant
+        :param tenant_name: name of tenant
+        :param auth_url: endpoint to authenticate against
+        """
+        return ksclient.Client(username=kwargs.get('username'),
+                               password=kwargs.get('password'),
+                               tenant_id=kwargs.get('tenant_id'),
+                               tenant_name=kwargs.get('tenant_name'),
+                               auth_url=kwargs.get('auth_url'),
+                               insecure=kwargs.get('insecure'))
+
+    def _get_endpoint(self, client, **kwargs):
+        """Get an endpoint using the provided keystone client."""
+        endpoint = client.service_catalog.url_for(
+                service_type=kwargs.get('service_type') or 'orchestration',
+                endpoint_type=kwargs.get('endpoint_type') or 'publicURL')
+        return self._strip_version(endpoint)
+
+    def main(self, argv):
+        # Parse args once to find version
+        parser = self.get_base_parser()
+        (options, args) = parser.parse_known_args(argv)
+
+        # build available subcommands based on version
+        api_version = options.heat_api_version
+        subcommand_parser = self.get_subcommand_parser(api_version)
+        self.parser = subcommand_parser
+
+        # Handle top-level --help/-h before attempting to parse
+        # a command off the command line
+        if options.help or not argv:
+            self.do_help(options)
+            return 0
+
+        # Parse args again and call whatever callback was selected
+        args = subcommand_parser.parse_args(argv)
+
+        # Short-circuit and deal with help command right away.
+        if args.func == self.do_help:
+            self.do_help(args)
+            return 0
+
+        LOG = logging.getLogger('heatclient')
+        LOG.addHandler(logging.StreamHandler())
+        LOG.setLevel(logging.DEBUG if args.debug else logging.INFO)
+
+        heat_url = args.heat_url
+        auth_reqd = (utils.is_authentication_required(args.func) and
+                     not (args.os_auth_token and heat_url))
+
+        if not auth_reqd:
+            endpoint = heat_url
+            token = args.os_auth_token
+        else:
+            if not args.os_username:
+                raise exc.CommandError("You must provide a username via"
+                        " either --os-username or env[OS_USERNAME]")
+
+            if not args.os_password:
+                raise exc.CommandError("You must provide a password via"
+                        " either --os-password or env[OS_PASSWORD]")
+
+            if not (args.os_tenant_id or args.os_tenant_name):
+                raise exc.CommandError("You must provide a tenant_id via"
+                        " either --os-tenant-id or via env[OS_TENANT_ID]")
+
+            if not args.os_auth_url:
+                raise exc.CommandError("You must provide an auth url via"
+                        " either --os-auth-url or via env[OS_AUTH_URL]")
+            kwargs = {
+                'username': args.os_username,
+                'password': args.os_password,
+                'tenant_id': args.os_tenant_id,
+                'tenant_name': args.os_tenant_name,
+                'auth_url': args.os_auth_url,
+                'service_type': args.os_service_type,
+                'endpoint_type': args.os_endpoint_type,
+                'insecure': args.insecure
+            }
+            _ksclient = self._get_ksclient(**kwargs)
+            token = args.os_auth_token or _ksclient.auth_token
+
+            endpoint = args.heat_url or \
+                    self._get_endpoint(_ksclient, **kwargs)
+
+        kwargs = {
+            'token': token,
+            'insecure': args.insecure,
+            'timeout': args.timeout,
+            'ca_file': args.ca_file,
+            'cert_file': args.cert_file,
+            'key_file': args.key_file,
+        }
+
+        client = heatclient.Client(api_version, endpoint, **kwargs)
+
+        try:
+            args.func(client, args)
+        except exc.Unauthorized:
+            raise exc.CommandError("Invalid OpenStack Identity credentials.")
+
+    @utils.arg('command', metavar='<subcommand>', nargs='?',
+               help='Display help for <subcommand>')
+    def do_help(self, args):
+        """
+        Display help about this program or one of its subcommands.
+        """
+        if getattr(args, 'command', None):
+            if args.command in self.subcommands:
+                self.subcommands[args.command].print_help()
+            else:
+                raise exc.CommandError("'%s' is not a valid subcommand" %
+                                       args.command)
+        else:
+            self.parser.print_help()
+
+
+class HelpFormatter(argparse.HelpFormatter):
+    def start_section(self, heading):
+        # Title-case the headings
+        heading = '%s%s' % (heading[0].upper(), heading[1:])
+        super(HelpFormatter, self).start_section(heading)
+
+
+def main():
+    try:
+        HeatShell().main(sys.argv[1:])
+
+    except Exception, e:
+        print >> sys.stderr, e
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

heatclient/v1/__init__.py

@@ -0,0 +1,16 @@
+# Copyright 2012 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from heatclient.v1.client import Client

heatclient/v1/client.py

@@ -0,0 +1,33 @@
+# Copyright 2012 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from heatclient.common import http
+from heatclient.v1 import stacks
+
+
+class Client(http.HTTPClient):
+    """Client for the Heat v1 API.
+
+    :param string endpoint: A user-supplied endpoint URL for the heat
+                            service.
+    :param string token: Token for authentication.
+    :param integer timeout: Allows customization of the timeout for client
+                            http requests. (optional)
+    """
+
+    def __init__(self, *args, **kwargs):
+        """ Initialize a new client for the Heat v1 API. """
+        super(Client, self).__init__(*args, **kwargs)
+        self.stacks = stacks.StackManager(self)

heatclient/v1/shell.py

@@ -0,0 +1,29 @@
+# Copyright 2012 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import argparse
+import copy
+import os
+import sys
+
+from heatclient.common import utils
+
+
+def do_list(hc, args):
+    print args
+    kwargs = {'tenant_id': args.os_tenant_name}
+    stacks = hc.stacks.list(**kwargs)
+    columns = ['ID', 'Name', 'Status']
+    utils.print_list(stacks, columns)

heatclient/v1/stacks.py

@@ -0,0 +1,198 @@
+# Copyright 2012 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import copy
+import errno
+import json
+import os
+import urllib
+
+from heatclient.common import base
+from heatclient.common import utils
+
+UPDATE_PARAMS = ('name', 'disk_format', 'container_format', 'min_disk',
+                 'min_ram', 'owner', 'size', 'is_public', 'protected',
+                 'location', 'checksum', 'copy_from', 'properties',
+                 #NOTE(bcwaldon: an attempt to update 'deleted' will be
+                 # ignored, but we need to support it for backwards-
+                 # compatibility with the legacy client library
+                 'deleted')
+
+CREATE_PARAMS = UPDATE_PARAMS + ('id',)
+
+DEFAULT_PAGE_SIZE = 20
+
+
+class Stack(base.Resource):
+    def __repr__(self):
+        return "<Image %s>" % self._info
+
+    def update(self, **fields):
+        self.manager.update(self, **fields)
+
+    def delete(self):
+        return self.manager.delete(self)
+
+    def data(self, **kwargs):
+        return self.manager.data(self, **kwargs)
+
+
+class StackManager(base.Manager):
+    resource_class = Stack
+
+#    def get(self, image_id):
+#        """Get the metadata for a specific stack.
+#
+#        :param image: image object or id to look up
+#        :rtype: :class:`Image`
+#        """
+#        resp, body = self.api.raw_request('HEAD', '/v1/images/%s' % image_id)
+#        meta = self._image_meta_from_headers(dict(resp.getheaders()))
+#        return Stack(self, meta)
+#
+#    def data(self, image, do_checksum=True):
+#        """Get the raw data for a specific image.
+#
+#        :param image: image object or id to look up
+#        :param do_checksum: Enable/disable checksum validation
+#        :rtype: iterable containing image data
+#        """
+#        image_id = base.getid(image)
+#        resp, body = self.api.raw_request('GET', '/v1/images/%s' % image_id)
+#        checksum = resp.getheader('x-image-meta-checksum', None)
+#        if do_checksum and checksum is not None:
+#            return utils.integrity_iter(body, checksum)
+#        else:
+#            return body
+
+    def list(self, **kwargs):
+        """Get a list of stacks.
+
+        :param page_size: number of items to request in each paginated request
+        :param limit: maximum number of stacks to return
+        :param marker: begin returning stacks that appear later in the stack
+                       list than that represented by this stack id
+        :param filters: dict of direct comparison filters that mimics the
+                        structure of a stack object
+        :rtype: list of :class:`Stack`
+        """
+        print kwargs
+        absolute_limit = kwargs.get('limit')
+
+        def paginate(qp, seen=0):
+            url = '/stacks?%s' % urllib.urlencode(qp)
+
+            stacks = self._list(url, "stacks")
+            for stack in stacks:
+                seen += 1
+                if absolute_limit is not None and seen > absolute_limit:
+                    return
+                yield stack
+
+            page_size = qp.get('limit')
+            if (page_size and len(stacks) == page_size and
+                    (absolute_limit is None or 0 < seen < absolute_limit)):
+                qp['marker'] = stack.id
+                for image in paginate(qp, seen):
+                    yield image
+
+        params = {'limit': kwargs.get('page_size', DEFAULT_PAGE_SIZE)}
+
+        if 'marker' in kwargs:
+            params['marker'] = kwargs['marker']
+
+        filters = kwargs.get('filters', {})
+        properties = filters.pop('properties', {})
+        for key, value in properties.items():
+            params['property-%s' % key] = value
+        params.update(filters)
+
+        return paginate(params)
+
+#    def delete(self, image):
+#        """Delete an image."""
+#        self._delete("/v1/images/%s" % base.getid(image))
+#
+#    def create(self, **kwargs):
+#        """Create an image
+#
+#        TODO(bcwaldon): document accepted params
+#        """
+#        image_data = kwargs.pop('data', None)
+#        if image_data is not None:
+#            image_size = self._get_file_size(image_data)
+#            if image_size != 0:
+#                kwargs.setdefault('size', image_size)
+#            else:
+#                image_data = None
+#
+#        fields = {}
+#        for field in kwargs:
+#            if field in CREATE_PARAMS:
+#                fields[field] = kwargs[field]
+#            else:
+#                msg = 'create() got an unexpected keyword argument \'%s\''
+#                raise TypeError(msg % field)
+#
+#        copy_from = fields.pop('copy_from', None)
+#        hdrs = self._image_meta_to_headers(fields)
+#        if copy_from is not None:
+#            hdrs['x-heat-api-copy-from'] = copy_from
+#
+#        resp, body_iter = self.api.raw_request(
+#                'POST', '/v1/images', headers=hdrs, body=image_data)
+#        body = json.loads(''.join([c for c in body_iter]))
+#        return Stack(self, self._format_image_meta_for_user(body['image']))
+#
+#    def update(self, image, **kwargs):
+#        """Update an image
+#
+#        TODO(bcwaldon): document accepted params
+#        """
+#        hdrs = {}
+#        image_data = kwargs.pop('data', None)
+#        if image_data is not None:
+#            image_size = self._get_file_size(image_data)
+#            if image_size != 0:
+#                kwargs.setdefault('size', image_size)
+#                hdrs['Content-Length'] = image_size
+#            else:
+#                image_data = None
+#
+#        try:
+#            purge_props = 'true' if kwargs.pop('purge_props') else 'false'
+#        except KeyError:
+#            pass
+#        else:
+#            hdrs['x-heat-registry-purge-props'] = purge_props
+#
+#        fields = {}
+#        for field in kwargs:
+#            if field in UPDATE_PARAMS:
+#                fields[field] = kwargs[field]
+#            else:
+#                msg = 'update() got an unexpected keyword argument \'%s\''
+#                raise TypeError(msg % field)
+#
+#        copy_from = fields.pop('copy_from', None)
+#        hdrs.update(self._image_meta_to_headers(fields))
+#        if copy_from is not None:
+#            hdrs['x-heat-api-copy-from'] = copy_from
+#
+#        url = '/v1/images/%s' % base.getid(image)
+#        resp, body_iter = self.api.raw_request(
+#                'PUT', url, headers=hdrs, body=image_data)
+#        body = json.loads(''.join([c for c in body_iter]))
+#        return Stack(self, self._format_image_meta_for_user(body['image']))

heatclient/version.py

@@ -0,0 +1,19 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+
+from heatclient.openstack.common import version as common_version
+
+version_info = common_version.VersionInfo('heatclient',
+                                          python_package='python-heatclient')

heatclient/versioninfo

@@ -0,0 +1 @@
+0.1.0

openstack-common.conf

@@ -0,0 +1,7 @@
+[DEFAULT]
+
+# The list of modules to copy from openstack-common
+modules=setup,importutils,version
+
+# The base module to hold the copy of openstack.common
+base=heatclient

run_tests.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+
+function usage {
+  echo "Usage: $0 [OPTION]..."
+  echo "Run python-heatclient's test suite(s)"
+  echo ""
+  echo "  -p, --pep8               Just run pep8"
+  echo "  -h, --help               Print this usage message"
+  echo ""
+  echo "This script is deprecated and currently retained for compatibility."
+  echo 'You can run the full test suite for multiple environments by running "tox".'
+  echo 'You can run tests for only python 2.7 by running "tox -e py27", or run only'
+  echo 'the pep8 tests with "tox -e pep8".'
+  exit
+}
+
+command -v tox > /dev/null 2>&1
+if [ $? -ne 0 ]; then
+  echo 'This script requires "tox" to run.'
+  echo 'You can install it with "pip install tox".'
+  exit 1; 
+fi
+
+just_pep8=0
+
+function process_option {
+  case "$1" in
+    -h|--help) usage;;
+    -p|--pep8) let just_pep8=1;;
+  esac
+}
+
+for arg in "$@"; do
+  process_option $arg
+done
+
+if [ $just_pep8 -eq 1 ]; then
+  tox -e pep8
+  exit
+fi
+
+tox -e py27 $toxargs 2>&1 | tee run_tests.err.log  || exit
+if [ ${PIPESTATUS[0]} -ne 0 ]; then
+  exit ${PIPESTATUS[0]}
+fi
+
+if [ -z "$toxargs" ]; then
+  tox -e pep8
+fi

setup.cfg

@@ -0,0 +1,15 @@
+[nosetests]
+cover-package = heatclient
+cover-html = true
+cover-erase = true
+cover-inclusive = true
+verbosity=2
+detailed-errors=1
+
+[build_sphinx]
+source-dir = doc/source
+build-dir = doc/build
+all_files = 1
+
+[upload_sphinx]
+upload-dir = doc/build/html

setup.py

@@ -0,0 +1,47 @@
+import os
+import sys
+
+import setuptools
+
+from heatclient.openstack.common import setup
+
+
+requires = setup.parse_requirements()
+dependency_links = setup.parse_dependency_links()
+tests_require = setup.parse_requirements(['tools/test-requires'])
+
+if sys.version_info < (2, 6):
+    requires.append('simplejson')
+
+
+def read(fname):
+    return open(os.path.join(os.path.dirname(__file__), fname)).read()
+
+setuptools.setup(
+    name="python-heatclient",
+    version=setup.get_post_version('heatclient'),
+    description="Client library for Heat orchestration API",
+    long_description=read('README.rst'),
+    url='https://github.com/heat-api/python-heatclient',
+    license='Apache',
+    author='Heat API Developers',
+    author_email='discuss@heat-api.org',
+    packages=setuptools.find_packages(exclude=['tests', 'tests.*']),
+    include_package_data=True,
+    classifiers=[
+        'Development Status :: 4 - Beta',
+        'Environment :: Console',
+        'Intended Audience :: Developers',
+        'Intended Audience :: Information Technology',
+        'License :: OSI Approved :: Apache Software License',
+        'Operating System :: OS Independent',
+        'Programming Language :: Python',
+    ],
+    cmdclass=setup.get_cmdclass(),
+    install_requires=requires,
+    dependency_links=dependency_links,
+    tests_require=tests_require,
+    setup_requires=['setuptools-git>=0.4'],
+    test_suite="nose.collector",
+    entry_points={'console_scripts': ['heat = heatclient.shell:main']},
+)

tests/test_foo.py

@@ -0,0 +1,7 @@
+import unittest
+
+
+class fooTest(unittest.TestCase):
+
+    def test_foo(self):
+        self.assertTrue(True)

tools/pip-requires

@@ -0,0 +1,4 @@
+argparse
+prettytable>=0.6,<0.7
+python-keystoneclient>=0.1.2,<0.2
+warlock<2

tools/test-requires

@@ -0,0 +1,11 @@
+distribute>=0.6.24
+
+mox
+nose
+nose-exclude
+nosexcover
+openstack.nose_plugin
+nosehtmloutput
+pep8==1.2
+setuptools-git>=0.4
+sphinx>=1.1.2

tools/with_venv.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+command -v tox > /dev/null 2>&1
+if [ $? -ne 0 ]; then
+  echo 'This script requires "tox" to run.'
+  echo 'You can install it with "pip install tox".'
+  exit 1; 
+fi
+
+tox -evenv -- $@

tox.ini

@@ -0,0 +1,46 @@
+[tox]
+envlist = py26,py27,pep8
+
+[testenv]
+setenv = VIRTUAL_ENV={envdir}
+         NOSE_WITH_OPENSTACK=1
+         NOSE_OPENSTACK_COLOR=1
+         NOSE_OPENSTACK_RED=0.05
+         NOSE_OPENSTACK_YELLOW=0.025
+         NOSE_OPENSTACK_SHOW_ELAPSED=1
+deps = -r{toxinidir}/tools/pip-requires
+       -r{toxinidir}/tools/test-requires
+commands = nosetests
+
+[testenv:pep8]
+deps = pep8==1.1
+commands = pep8 --repeat --show-source heatclient setup.py
+
+[testenv:venv]
+commands = {posargs}
+
+[testenv:cover]
+commands = nosetests --cover-erase --cover-package=heatclient --with-xcoverage
+
+[tox:jenkins]
+downloadcache = ~/cache/pip
+
+[testenv:jenkins26]
+basepython = python2.6
+setenv = NOSE_WITH_XUNIT=1
+deps = file://{toxinidir}/.cache.bundle
+
+[testenv:jenkins27]
+basepython = python2.7
+setenv = NOSE_WITH_XUNIT=1
+deps = file://{toxinidir}/.cache.bundle
+
+[testenv:jenkinscover]
+deps = file://{toxinidir}/.cache.bundle
+setenv = NOSE_WITH_XUNIT=1
+commands = nosetests --cover-erase --cover-package=heatclient --with-xcoverage
+
+[testenv:jenkinsvenv]
+deps = file://{toxinidir}/.cache.bundle
+setenv = NOSE_WITH_XUNIT=1
+commands = {posargs}