Add new python-seamicroclient

* Using Seamicro Chassis REST API 2.0

.coveragerc

@@ -0,0 +1,7 @@
+[run]
+branch = True
+source = seamicroclient
+omit = seamicroclient/openstack/*
+
+[report]
+ignore-errors = True

.gitignore

@@ -1,36 +1,18 @@
-*.py[cod]
-.venv
-
-# C extensions
-*.so
-
-# Packages
-*.egg
-*.egg-info
-dist
-build
-eggs
-parts
-bin
-var
-sdist
-develop-eggs
-.installed.cfg
-lib
-lib64
-
-# Installer logs
-pip-log.txt
-
-# Unit test / coverage reports
 .coverage
+.venv
+.testrepository
+subunit.log
 .tox
-nosetests.xml
-
-# Translations
-*.mo
-
-# Mr Developer
-.mr.developer.cfg
-.project
-.pydevproject
+*,cover
+cover
+*.pyc
+.idea
+*.sw?
+*~
+build
+dist
+AUTHORS
+ChangeLog
+seamicroclient/versioninfo
+*.egg
+*egg-info

.gitreview

@@ -0,0 +1,4 @@
+[gerrit]
+host=amd_dmz_gerrit_ip
+port=29418
+project=openstack/python-seamicroclient.git

.testr.conf

@@ -0,0 +1,4 @@
+[DEFAULT]
+test_command=OS_STDOUT_CAPTURE=${OS_STDOUT_CAPTURE:-1} OS_STDERR_CAPTURE=${OS_STDERR_CAPTURE:-1} ${PYTHON:-python} -m subunit.run discover -t ./ ./ $LISTOPT $IDOPTION
+test_id_option=--load-list $IDFILE
+test_list_option=--list

HACKING.rst

@@ -0,0 +1,59 @@
+Seamicro Client Style Commandments
+==============================
+
+- Step 1: Read the OpenStack Style Commandments
+  http://docs.openstack.org/developer/hacking
+- Step 2: Read on
+
+
+Seamicro Client Specific Commandments
+---------------------------------
+None so far
+
+Text encoding
+-------------
+- All text within python code should be of type 'unicode'.
+
+    WRONG:
+
+    >>> s = 'foo'
+    >>> s
+    'foo'
+    >>> type(s)
+    <type 'str'>
+
+    RIGHT:
+
+    >>> u = u'foo'
+    >>> u
+    u'foo'
+    >>> type(u)
+    <type 'unicode'>
+
+- Transitions between internal unicode and external strings should always
+  be immediately and explicitly encoded or decoded.
+
+- All external text that is not explicitly encoded (database storage,
+  commandline arguments, etc.) should be presumed to be encoded as utf-8.
+
+    WRONG:
+
+    mystring = infile.readline()
+    myreturnstring = do_some_magic_with(mystring)
+    outfile.write(myreturnstring)
+
+    RIGHT:
+
+    mystring = infile.readline()
+    mytext = s.decode('utf-8')
+    returntext = do_some_magic_with(mytext)
+    returnstring = returntext.encode('utf-8')
+    outfile.write(returnstring)
+
+Running Tests
+-------------
+The testing system is based on a combination of tox and testr. If you just
+want to run the whole suite, run `tox` and all will be fine. However, if
+you'd like to dig in a bit more, you might want to learn some things about
+testr itself. A basic walkthrough for OpenStack can be found at
+http://wiki.openstack.org/testr

LICENSE

@@ -0,0 +1 @@
+AMD LICENSE HERE

MANIFEST.in

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

examples/README.rst

@@ -0,0 +1,3 @@
+To run example script
+
+PYTHONPATH=./../seamicroclient/ python ./server_example.py

examples/server_example.py

@@ -0,0 +1,11 @@
+import json
+
+from seamicroclient.v2 import client
+
+seamicro = client.Client("admin", "seamicro", "http://172.16.0.25/v2.0")
+
+servers = seamicro.servers.list()
+
+for server in servers:
+    print json.dumps(server)
+    print "\n\n"

openstack-common.conf

@@ -0,0 +1,11 @@
+[DEFAULT]
+
+# The list of modules to copy from openstack-common
+module=install_venv_common
+module=strutils
+module=timeutils
+module=uuidutils
+module=py3kcompat
+
+# The base module to hold the copy of openstack.common
+base=seamicroclient

requirements.txt

@@ -1,3 +1,14 @@
+# python-seamicroclient v0.9 requirements
 enum==0.4.4
-requests==2.0.1
 wsgiref==0.1.2
+
+
+# python-seamicroclient v2.0 requirements
+pbr>=0.5.21,<1.0
+argparse
+iso8601>=0.1.8
+PrettyTable>=0.7,<0.8
+requests>=1.1
+simplejson>=2.0.9
+six>=1.4.1
+Babel>=1.3

run_tests.sh

@@ -0,0 +1,164 @@
+#!/bin/bash
+
+set -eu
+
+function usage {
+  echo "Usage: $0 [OPTION]..."
+  echo "Run python-seamicroclient test suite"
+  echo ""
+  echo "  -V, --virtual-env        Always use virtualenv.  Install automatically if not present"
+  echo "  -N, --no-virtual-env     Don't use virtualenv.  Run tests in local environment"
+  echo "  -s, --no-site-packages   Isolate the virtualenv from the global Python environment"
+  echo "  -x, --stop               Stop running tests after the first error or failure."
+  echo "  -f, --force              Force a clean re-build of the virtual environment. Useful when dependencies have been added."
+  echo "  -p, --pep8               Just run pep8"
+  echo "  -P, --no-pep8            Don't run pep8"
+  echo "  -c, --coverage           Generate coverage report"
+  echo "  -h, --help               Print this usage message"
+  echo "  --hide-elapsed           Don't print the elapsed time for each test along with slow test list"
+  echo ""
+  echo "Note: with no options specified, the script will try to run the tests in a virtual environment,"
+  echo "      If no virtualenv is found, the script will ask if you would like to create one.  If you "
+  echo "      prefer to run tests NOT in a virtual environment, simply pass the -N option."
+  exit
+}
+
+function process_option {
+  case "$1" in
+    -h|--help) usage;;
+    -V|--virtual-env) always_venv=1; never_venv=0;;
+    -N|--no-virtual-env) always_venv=0; never_venv=1;;
+    -s|--no-site-packages) no_site_packages=1;;
+    -f|--force) force=1;;
+    -p|--pep8) just_pep8=1;;
+    -P|--no-pep8) no_pep8=1;;
+    -c|--coverage) coverage=1;;
+    -*) testropts="$testropts $1";;
+    *) testrargs="$testrargs $1"
+  esac
+}
+
+venv=.venv
+with_venv=tools/with_venv.sh
+always_venv=0
+never_venv=0
+force=0
+no_site_packages=0
+installvenvopts=
+testrargs=
+testropts=
+wrapper=""
+just_pep8=0
+no_pep8=0
+coverage=0
+
+LANG=en_US.UTF-8
+LANGUAGE=en_US:en
+LC_ALL=C
+
+for arg in "$@"; do
+  process_option $arg
+done
+
+if [ $no_site_packages -eq 1 ]; then
+  installvenvopts="--no-site-packages"
+fi
+
+function init_testr {
+  if [ ! -d .testrepository ]; then
+    ${wrapper} testr init
+  fi
+}
+
+function run_tests {
+  # Cleanup *pyc
+  ${wrapper} find . -type f -name "*.pyc" -delete
+
+  if [ $coverage -eq 1 ]; then
+    # Do not test test_coverage_ext when gathering coverage.
+    if [ "x$testrargs" = "x" ]; then
+      testrargs="^(?!.*test_coverage_ext).*$"
+    fi
+    export PYTHON="${wrapper} coverage run --source seamicroclient --parallel-mode"
+  fi
+  # Just run the test suites in current environment
+  set +e
+  TESTRTESTS="$TESTRTESTS $testrargs"
+  echo "Running \`${wrapper} $TESTRTESTS\`"
+  ${wrapper} $TESTRTESTS
+  RESULT=$?
+  set -e
+
+  copy_subunit_log
+
+  return $RESULT
+}
+
+function copy_subunit_log {
+  LOGNAME=`cat .testrepository/next-stream`
+  LOGNAME=$(($LOGNAME - 1))
+  LOGNAME=".testrepository/${LOGNAME}"
+  cp $LOGNAME subunit.log
+}
+
+function run_pep8 {
+  echo "Running flake8 ..."
+  ${wrapper} flake8
+}
+
+TESTRTESTS="testr run --parallel $testropts"
+
+if [ $never_venv -eq 0 ]
+then
+  # Remove the virtual environment if --force used
+  if [ $force -eq 1 ]; then
+    echo "Cleaning virtualenv..."
+    rm -rf ${venv}
+  fi
+  if [ -e ${venv} ]; then
+    wrapper="${with_venv}"
+  else
+    if [ $always_venv -eq 1 ]; then
+      # Automatically install the virtualenv
+      python tools/install_venv.py $installvenvopts
+      wrapper="${with_venv}"
+    else
+      echo -e "No virtual environment found...create one? (Y/n) \c"
+      read use_ve
+      if [ "x$use_ve" = "xY" -o "x$use_ve" = "x" -o "x$use_ve" = "xy" ]; then
+        # Install the virtualenv and run the test suite in it
+        python tools/install_venv.py $installvenvopts
+        wrapper=${with_venv}
+      fi
+    fi
+  fi
+fi
+
+# Delete old coverage data from previous runs
+if [ $coverage -eq 1 ]; then
+    ${wrapper} coverage erase
+fi
+
+if [ $just_pep8 -eq 1 ]; then
+    run_pep8
+    exit
+fi
+
+init_testr
+run_tests
+
+# NOTE(sirp): we only want to run pep8 when we're running the full-test suite,
+# not when we're running tests individually. To handle this, we need to
+# distinguish between options (noseopts), which begin with a '-', and
+# arguments (testrargs).
+if [ -z "$testrargs" ]; then
+  if [ $no_pep8 -eq 0 ]; then
+    run_pep8
+  fi
+fi
+
+if [ $coverage -eq 1 ]; then
+    echo "Generating coverage report in covhtml/"
+    ${wrapper} coverage combine
+    ${wrapper} coverage html --include='seamicroclient/*' --omit='seamicroclient/openstack/common/*' -d covhtml -i
+fi

runtests.sh

@@ -0,0 +1 @@
+nosetests -v --with-coverage --cover-html --cover-html-dir=./cover seamicroclient

seamicroclient/__init__.py

@@ -0,0 +1,18 @@
+#   Copyright 2012 OpenStack Foundation
+#
+#   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 pbr.version
+
+
+#__version__ = pbr.version.VersionInfo('python-seamicroclient').version_string()

seamicroclient/base.py

@@ -0,0 +1,241 @@
+#    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 abc
+import inspect
+
+import six
+
+from seamicroclient import exceptions
+from seamicroclient.openstack.common import strutils
+from seamicroclient import utils
+
+
+def getid(obj):
+    """
+    Abstracts the common pattern of allowing both an object or an object's ID
+    as a parameter when dealing with relationships.
+    """
+    try:
+        return obj.id
+    except AttributeError:
+        return obj
+
+
+class Manager(utils.HookableMixin):
+
+    """
+    Managers interact with a particular type of API (servers, storage
+    etc.) and provide CRUD operations for them.
+    """
+    resource_class = None
+
+    def __init__(self, api):
+        self.api = api
+
+    def _list(self, url, body=None):
+        if body:
+            _resp, body = self.api.client.post(url, body=body)
+        else:
+            _resp, body = self.api.client.get(url)
+
+        obj_class = self.resource_class
+
+        data = body
+
+        output = []
+        for k, v in data.iteritems():
+            if data[k]:
+                v.update({'id': k})
+                output.append(obj_class(self, v, loaded=True))
+        return output
+
+    def _get(self, id, url):
+        _resp, body = self.api.client.get(url)
+        body.update({'id': id})
+        return self.resource_class(self, body)
+
+    def _create(self, url, body, return_raw=False, **kwargs):
+        self.run_hooks('modify_body_for_create', body, **kwargs)
+        _resp, body = self.api.client.post(url, body=body)
+        if return_raw:
+            return body
+        for k, v in body.iteritems():
+            v.update({'id': k})
+            return self.resource_class(self, v)
+
+    def _delete(self, url):
+        _resp, _body = self.api.client.delete(url)
+
+    def _update(self, url, body, **kwargs):
+        self.run_hooks('modify_body_for_update', body, **kwargs)
+        _resp, body = self.api.client.put(url, body=body)
+        if body:
+            if body == kwargs.get('action'):
+                return
+            for k, v in body.iteritems():
+                v.update({'id': k})
+                return self.resource_class(self, v)
+
+
+@six.add_metaclass(abc.ABCMeta)
+class ManagerWithFind(Manager):
+
+    """
+    Like a `Manager`, but with additional `find()`/`findall()` methods.
+    """
+
+    @abc.abstractmethod
+    def list(self):
+        pass
+
+    def find(self, **kwargs):
+        """
+        Find a single item with attributes matching ``**kwargs``.
+
+        This isn't very efficient: it loads the entire list then filters on
+        the Python side.
+        """
+        matches = self.findall(**kwargs)
+        num_matches = len(matches)
+        if num_matches == 0:
+            msg = "No %s matching %s." % (self.resource_class.__name__, kwargs)
+            raise exceptions.NotFound(404, msg)
+        elif num_matches > 1:
+            raise exceptions.NoUniqueMatch
+        else:
+            return matches[0]
+
+    def findall(self, **kwargs):
+        """
+        Find all items with attributes matching ``**kwargs``.
+
+        This isn't very efficient: it loads the entire list then filters on
+        the Python side.
+        """
+        found = []
+        searches = kwargs.items()
+
+        detailed = True
+        list_kwargs = {}
+
+        list_argspec = inspect.getargspec(self.list)
+        if 'detailed' in list_argspec.args:
+            detailed = ("human_id" not in kwargs and
+                        "name" not in kwargs and
+                        "display_name" not in kwargs)
+            list_kwargs['detailed'] = detailed
+
+        if 'is_public' in list_argspec.args and 'is_public' in kwargs:
+            is_public = kwargs['is_public']
+            list_kwargs['is_public'] = is_public
+            if is_public is None:
+                tmp_kwargs = kwargs.copy()
+                del tmp_kwargs['is_public']
+                searches = tmp_kwargs.items()
+
+        listing = self.list(**list_kwargs)
+
+        for obj in listing:
+            try:
+                if all(getattr(obj, attr) == value
+                        for (attr, value) in searches):
+                    if detailed:
+                        found.append(obj)
+                    else:
+                        found.append(self.get(obj.id))
+            except AttributeError:
+                continue
+
+        return found
+
+
+class Resource(object):
+
+    """
+    A resource represents a particular instance of an object (server, flavor,
+    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
+    """
+    HUMAN_ID = False
+    NAME_ATTR = 'id'
+
+    def __init__(self, manager, info, loaded=False):
+        self.manager = manager
+        self._info = info
+        self._add_details(info)
+        self._loaded = loaded
+
+    @property
+    def human_id(self):
+        """Subclasses may override this provide a pretty ID which can be used
+        for bash completion.
+        """
+        if self.NAME_ATTR in self.__dict__ and self.HUMAN_ID:
+            return strutils.to_slug(getattr(self, self.NAME_ATTR))
+        return None
+
+    def _add_details(self, info):
+        for (k, v) in six.iteritems(info):
+            try:
+                setattr(self, k, v)
+                self._info[k] = v
+            except AttributeError:
+                # In this case we already defined the attribute on the class
+                pass
+
+    def __getattr__(self, k):
+        if k not in self.__dict__:
+            # NOTE(rk): 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

seamicroclient/client.py

@@ -0,0 +1,249 @@
+# 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.
+
+"""
+Seamicro Client interface. Handles the REST calls and responses.
+"""
+
+import logging
+import time
+
+import requests
+
+try:
+    import json
+except ImportError:
+    import simplejson as json
+
+from seamicroclient import exceptions
+from seamicroclient import utils
+
+
+class HTTPClient(object):
+
+    USER_AGENT = 'python-seamicroclient'
+
+    def __init__(self, user, password, auth_url=None,
+                 timeout=None, http_log_debug=False):
+        self.user = user
+        self.password = password
+        self.api_endpoint = auth_url.replace("/login", "")
+        self.auth_url = auth_url.rstrip('/')
+        self.version = 'v2.0'
+        self.http_log_debug = http_log_debug
+        if timeout is not None:
+            self.timeout = float(timeout)
+        else:
+            self.timeout = None
+
+        self.times = []  # [("item", starttime, endtime), ...]
+
+        self.auth_token = None
+
+        self._logger = logging.getLogger(__name__)
+        if self.http_log_debug and not self._logger.handlers:
+            # Logging level is already set on the root logger
+            ch = logging.StreamHandler()
+            self._logger.addHandler(ch)
+            self._logger.propagate = False
+            if hasattr(requests, 'logging'):
+                rql = requests.logging.getLogger(requests.__name__)
+                rql.addHandler(ch)
+                # Since we have already setup the root logger on debug, we
+                # have to set it up here on WARNING (its original level)
+                # otherwise we will get all the requests logging messanges
+                rql.setLevel(logging.WARNING)
+        # requests within the same session can reuse TCP connections from pool
+        self.http = requests.Session()
+
+    def unauthenticate(self):
+        """Forget all of our authentication information."""
+        self.auth_token = None
+
+    def get_timings(self):
+        return self.times
+
+    def reset_timings(self):
+        self.times = []
+
+    def http_log_req(self, method, url, kwargs):
+        if not self.http_log_debug:
+            return
+
+        string_parts = ['curl -i']
+
+        string_parts.append(" '%s'" % url)
+        string_parts.append(' -X %s' % method)
+
+        for element in kwargs['headers']:
+            header = ' -H "%s: %s"' % (element, kwargs['headers'][element])
+            string_parts.append(header)
+
+        if 'data' in kwargs:
+            string_parts.append(" -d '%s'" % (kwargs['data']))
+        self._logger.debug("\nREQ: %s\n" % "".join(string_parts))
+
+    def http_log_resp(self, resp):
+        if not self.http_log_debug:
+            return
+        self._logger.debug(
+            "RESP: [%s] %s\nRESP BODY: %s\n",
+            resp.status_code,
+            resp.headers,
+            resp.text)
+
+    def request(self, url, method, **kwargs):
+        kwargs.setdefault('headers', kwargs.get('headers', {}))
+        kwargs['headers']['User-Agent'] = self.USER_AGENT
+        kwargs['headers']['Accept'] = 'application/json'
+        if 'body' in kwargs:
+            kwargs['headers']['Content-Type'] = 'application/json'
+            kwargs['data'] = json.dumps(kwargs['body'])
+            del kwargs['body']
+        if self.timeout is not None:
+            kwargs.setdefault('timeout', self.timeout)
+
+        self.http_log_req(method, url, kwargs)
+        resp = self.http.request(
+            method,
+            url,
+            **kwargs)
+        self.http_log_resp(resp)
+
+        if resp.text:
+            # httplib2 returns a connection refused event as a 400 response.
+            # To determine if it is a bad request or refused connection we need
+            # to check the body.  httplib2 tests check for 'Connection refused'
+            # or 'actively refused' in the body, so that's what we'll do.
+            if resp.status_code == 400:
+                if ('Connection refused' in resp.text or
+                        'actively refused' in resp.text):
+                    raise exceptions.ConnectionRefused(resp.text)
+            try:
+                body = json.loads(resp.text)
+            except ValueError:
+                body = resp.text
+        else:
+            body = None
+
+        if resp.status_code >= 400:
+            raise exceptions.from_response(resp, body, url, method)
+
+        return resp, body
+
+    def _time_request(self, url, method, **kwargs):
+        start_time = time.time()
+        resp, body = self.request(url, method, **kwargs)
+        self.times.append(("%s %s" % (method, url),
+                           start_time, time.time()))
+        return resp, body
+
+    def _cs_request(self, url, method, **kwargs):
+        if self.auth_token:
+            if method in ['GET', 'DELETE']:
+                url = "%s?%s=%s" % (url, "authtoken", self.auth_token)
+            else:
+                kwargs.setdefault('body', {})['authtoken'] = self.auth_token
+
+        # Perform the request once. If we get a 401 back then it
+        # might be because the auth token expired, so try to
+        # re-authenticate and try again. If it still fails, bail.
+        try:
+
+            resp, body = self._time_request(self.api_endpoint + url, method,
+                                            **kwargs)
+            return resp, body
+        except (exceptions.Unauthorized, exceptions.BadRequest) as e:
+            try:
+                # first discard auth token, to avoid the possibly expired
+                # token being re-used in the re-authentication attempt
+                self.unauthenticate()
+                self.authenticate()
+                if method in ['GET', 'DELETE']:
+                    url = "%s?%s=%s" % (url, "authtoken", self.auth_token)
+                else:
+                    kwargs.setdefault(
+                        'body', {})['authtoken'] = self.auth_token
+
+                resp, body = self._time_request(self.api_endpoint + url,
+                                                method, **kwargs)
+                return resp, body
+            except exceptions.Unauthorized:
+                raise e
+
+    def get(self, url, **kwargs):
+        return self._cs_request(url, 'GET', **kwargs)
+
+    def post(self, url, **kwargs):
+        return self._cs_request(url, 'POST', **kwargs)
+
+    def put(self, url, **kwargs):
+        return self._cs_request(url, 'PUT', **kwargs)
+
+    def delete(self, url, **kwargs):
+        return self._cs_request(url, 'DELETE', **kwargs)
+
+    def authenticate(self):
+        auth_url = self.auth_url
+        if self.version == "v2.0":  # FIXME(rk): This should be better.
+            self._v2_auth(auth_url)
+
+    def _v2_auth(self, url):
+        """Authenticate against a v2.0 auth service."""
+        if self.auth_token:
+            return
+        else:
+            body = {"username": self.user, "password": self.password}
+
+        return self._authenticate(url, body)
+
+    def _authenticate(self, url, body, **kwargs):
+        """Authenticate and extract the service catalog."""
+        method = "POST"
+        token_url = url + "/login"
+
+        # Make sure we follow redirects when trying to reach Keystone
+        resp, respbody = self._time_request(
+            token_url,
+            method,
+            body=body,
+            allow_redirects=True,
+            **kwargs)
+
+        return self._extract_auth_token(url, resp, respbody)
+
+    def _extract_auth_token(self, url, resp, body):
+        if resp.status_code == 200 or resp.status_code == 201:
+            if 'OpaqueRef' not in body:
+                raise exceptions.AuthorizationFailure()
+            self.auth_token = body
+
+
+def get_client_class(version):
+    version_map = {
+        '2': 'seamicroclient.v2.client.Client',
+    }
+    try:
+        client_path = version_map[str(version)]
+    except (KeyError, ValueError):
+        msg = "Invalid client version '%s'. must be one of: %s" % (
+              (version, ', '.join(version_map.keys())))
+        raise exceptions.UnsupportedVersion(msg)
+
+    return utils.import_class(client_path)
+
+
+def Client(version, *args, **kwargs):
+    client_class = get_client_class(version)
+    return client_class(*args, **kwargs)

seamicroclient/exceptions.py

@@ -0,0 +1,243 @@
+#    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.
+
+"""
+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,
+                 url=None, method=None):
+        self.code = code
+        self.message = message or self.__class__.message
+        self.details = details
+        self.request_id = request_id
+        self.url = url
+        self.method = method
+
+    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 MethodNotAllowed(ClientException):
+
+    """
+    HTTP 405 - Method Not Allowed
+    """
+    http_status = 405
+    message = "Method Not Allowed"
+
+
+class Conflict(ClientException):
+
+    """
+    HTTP 409 - Conflict
+    """
+    http_status = 409
+    message = "Conflict"
+
+
+class OverLimit(ClientException):
+
+    """
+    HTTP 413 - Over limit: you're over the API limits for this time period.
+    """
+    http_status = 413
+    message = "Over limit"
+
+    def __init__(self, *args, **kwargs):
+        try:
+            self.retry_after = int(kwargs.pop('retry_after'))
+        except (KeyError, ValueError):
+            self.retry_after = 0
+
+        super(OverLimit, self).__init__(*args, **kwargs)
+
+
+class RateLimit(OverLimit):
+
+    """
+    HTTP 429 - Rate limit: you've sent too many requests for this time period.
+    """
+    http_status = 429
+    message = "Rate 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:
+_error_classes = [BadRequest, Unauthorized, Forbidden, NotFound,
+                  MethodNotAllowed, Conflict, OverLimit, RateLimit,
+                  HTTPNotImplemented]
+_code_map = dict((c.http_status, c) for c in _error_classes)
+
+
+def from_response(response, body, url, method=None):
+    """
+    Return an instance of an ClientException or subclass
+    based on an requests response.
+
+    Usage::
+
+        resp, body = requests.request(...)
+        if resp.status_code != 200:
+            raise exception_from_response(resp, rest.text)
+    """
+    kwargs = {
+        'code': response.status_code,
+        'method': method,
+        'url': url,
+    }
+
+    if body:
+        message = "n/a"
+        details = "n/a"
+
+        if hasattr(body, 'keys'):
+            error = body[list(body)[1]]
+            message = error.get('message', None)
+            details = error.get('details', None)
+
+        kwargs['message'] = message
+        kwargs['details'] = details
+
+    cls = _code_map.get(response.status_code, ClientException)
+    return cls(**kwargs)

seamicroclient/openstack/common/gettextutils.py

@@ -0,0 +1,328 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2012 Red Hat, Inc.
+# Copyright 2013 IBM Corp.
+# 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.
+
+"""
+gettext for openstack-common modules.
+
+Usual usage in an openstack.common module:
+
+    from seamicroclient.openstack.common.gettextutils import _
+"""
+
+import copy
+import gettext
+import logging
+import os
+import re
+try:
+    import UserString as _userString
+except ImportError:
+    import collections as _userString
+
+from babel import localedata
+import six
+
+_localedir = os.environ.get('seamicroclient'.upper() + '_LOCALEDIR')
+_t = gettext.translation('seamicroclient', localedir=_localedir, fallback=True)
+
+_AVAILABLE_LANGUAGES = {}
+USE_LAZY = False
+
+
+def enable_lazy():
+    """Convenience function for configuring _() to use lazy gettext
+
+    Call this at the start of execution to enable the gettextutils._
+    function to use lazy gettext functionality. This is useful if
+    your project is importing _ directly instead of using the
+    gettextutils.install() way of importing the _ function.
+    """
+    global USE_LAZY
+    USE_LAZY = True
+
+
+def _(msg):
+    if USE_LAZY:
+        return Message(msg, 'seamicroclient')
+    else:
+        return _t.ugettext(msg)
+
+
+def install(domain, lazy=False):
+    """Install a _() function using the given translation domain.
+
+    Given a translation domain, install a _() function using gettext's
+    install() function.
+
+    The main difference from gettext.install() is that we allow
+    overriding the default localedir (e.g. /usr/share/locale) using
+    a translation-domain-specific environment variable (e.g.
+    NOVA_LOCALEDIR).
+
+    :param domain: the translation domain
+    :param lazy: indicates whether or not to install the lazy _() function.
+                 The lazy _() introduces a way to do deferred translation
+                 of messages by installing a _ that builds Message objects,
+                 instead of strings, which can then be lazily translated into
+                 any available locale.
+    """
+    if lazy:
+        # NOTE(mrodden): Lazy gettext functionality.
+        #
+        # The following introduces a deferred way to do translations on
+        # messages in OpenStack. We override the standard _() function
+        # and % (format string) operation to build Message objects that can
+        # later be translated when we have more information.
+        #
+        # Also included below is an example LocaleHandler that translates
+        # Messages to an associated locale, effectively allowing many logs,
+        # each with their own locale.
+
+        def _lazy_gettext(msg):
+            """Create and return a Message object.
+
+            Lazy gettext function for a given domain, it is a factory method
+            for a project/module to get a lazy gettext function for its own
+            translation domain (i.e. seamicro etc.)
+
+            Message encapsulates a string so that we can translate
+            it later when needed.
+            """
+            return Message(msg, domain)
+
+        import __builtin__
+        __builtin__.__dict__['_'] = _lazy_gettext
+    else:
+        localedir = '%s_LOCALEDIR' % domain.upper()
+        gettext.install(domain,
+                        localedir=os.environ.get(localedir),
+                        unicode=True)
+
+
+class Message(_userString.UserString, object):
+
+    """Class used to encapsulate translatable messages."""
+
+    def __init__(self, msg, domain):
+        # _msg is the gettext msgid and should never change
+        self._msg = msg
+        self._left_extra_msg = ''
+        self._right_extra_msg = ''
+        self.params = None
+        self.locale = None
+        self.domain = domain
+
+    @property
+    def data(self):
+        # NOTE(mrodden): this should always resolve to a unicode string
+        # that best represents the state of the message currently
+
+        localedir = os.environ.get(self.domain.upper() + '_LOCALEDIR')
+        if self.locale:
+            lang = gettext.translation(self.domain,
+                                       localedir=localedir,
+                                       languages=[self.locale],
+                                       fallback=True)
+        else:
+            # use system locale for translations
+            lang = gettext.translation(self.domain,
+                                       localedir=localedir,
+                                       fallback=True)
+
+        full_msg = (self._left_extra_msg +
+                    lang.ugettext(self._msg) +
+                    self._right_extra_msg)
+
+        if self.params is not None:
+            full_msg = full_msg % self.params
+
+        return six.text_type(full_msg)
+
+    def _save_dictionary_parameter(self, dict_param):
+        full_msg = self.data
+        # look for %(blah) fields in string;
+        # ignore %% and deal with the
+        # case where % is first character on the line
+        keys = re.findall('(?:[^%]|^)?%\((\w*)\)[a-z]', full_msg)
+
+        # if we don't find any %(blah) blocks but have a %s
+        if not keys and re.findall('(?:[^%]|^)%[a-z]', full_msg):
+            # apparently the full dictionary is the parameter
+            params = copy.deepcopy(dict_param)
+        else:
+            params = {}
+            for key in keys:
+                try:
+                    params[key] = copy.deepcopy(dict_param[key])
+                except TypeError:
+                    # cast uncopyable thing to unicode string
+                    params[key] = unicode(dict_param[key])
+
+        return params
+
+    def _save_parameters(self, other):
+        # we check for None later to see if
+        # we actually have parameters to inject,
+        # so encapsulate if our parameter is actually None
+        if other is None:
+            self.params = (other, )
+        elif isinstance(other, dict):
+            self.params = self._save_dictionary_parameter(other)
+        else:
+            # fallback to casting to unicode,
+            # this will handle the problematic python code-like
+            # objects that cannot be deep-copied
+            try:
+                self.params = copy.deepcopy(other)
+            except TypeError:
+                self.params = unicode(other)
+
+        return self
+
+    # overrides to be more string-like
+    def __unicode__(self):
+        return self.data
+
+    def __str__(self):
+        return self.data.encode('utf-8')
+
+    def __getstate__(self):
+        to_copy = ['_msg', '_right_extra_msg', '_left_extra_msg',
+                   'domain', 'params', 'locale']
+        new_dict = self.__dict__.fromkeys(to_copy)
+        for attr in to_copy:
+            new_dict[attr] = copy.deepcopy(self.__dict__[attr])
+
+        return new_dict
+
+    def __setstate__(self, state):
+        for (k, v) in state.items():
+            setattr(self, k, v)
+
+    # operator overloads
+    def __add__(self, other):
+        copied = copy.deepcopy(self)
+        copied._right_extra_msg += other.__str__()
+        return copied
+
+    def __radd__(self, other):
+        copied = copy.deepcopy(self)
+        copied._left_extra_msg += other.__str__()
+        return copied
+
+    def __mod__(self, other):
+        # do a format string to catch and raise
+        # any possible KeyErrors from missing parameters
+        self.data % other
+        copied = copy.deepcopy(self)
+        return copied._save_parameters(other)
+
+    def __mul__(self, other):
+        return self.data * other
+
+    def __rmul__(self, other):
+        return other * self.data
+
+    def __getitem__(self, key):
+        return self.data[key]
+
+    def __getslice__(self, start, end):
+        return self.data.__getslice__(start, end)
+
+    def __getattribute__(self, name):
+        # NOTE(mrodden): handle lossy operations that we can't deal with yet
+        # These override the UserString implementation, since UserString
+        # uses our __class__ attribute to try and build a new message
+        # after running the inner data string through the operation.
+        # At that point, we have lost the gettext message id and can just
+        # safely resolve to a string instead.
+        ops = ['capitalize', 'center', 'decode', 'encode',
+               'expandtabs', 'ljust', 'lstrip', 'replace', 'rjust', 'rstrip',
+               'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
+        if name in ops:
+            return getattr(self.data, name)
+        else:
+            return _userString.UserString.__getattribute__(self, name)
+
+
+def get_available_languages(domain):
+    """Lists the available languages for the given translation domain.
+
+    :param domain: the domain to get languages for
+    """
+    if domain in _AVAILABLE_LANGUAGES:
+        return copy.copy(_AVAILABLE_LANGUAGES[domain])
+
+    localedir = '%s_LOCALEDIR' % domain.upper()
+    find = lambda x: gettext.find(domain,
+                                  localedir=os.environ.get(localedir),
+                                  languages=[x])
+
+    # NOTE(mrodden): en_US should always be available (and first in case
+    # order matters) since our in-line message strings are en_US
+    language_list = ['en_US']
+    # NOTE(luisg): Babel <1.0 used a function called list(), which was
+    # renamed to locale_identifiers() in >=1.0, the requirements master list
+    # requires >=0.9.6, uncapped, so defensively work with both. We can remove
+    # this check when the master list updates to >=1.0, and all projects udpate
+    list_identifiers = (getattr(localedata, 'list', None) or
+                        getattr(localedata, 'locale_identifiers'))
+    locale_identifiers = list_identifiers()
+    for i in locale_identifiers:
+        if find(i) is not None:
+            language_list.append(i)
+    _AVAILABLE_LANGUAGES[domain] = language_list
+    return copy.copy(language_list)
+
+
+def get_localized_message(message, user_locale):
+    """Gets a localized version of the given message in the given locale."""
+    if isinstance(message, Message):
+        if user_locale:
+            message.locale = user_locale
+        return unicode(message)
+    else:
+        return message
+
+
+class LocaleHandler(logging.Handler):
+
+    """Handler that can have a locale associated to translate Messages.
+
+    A quick example of how to utilize the Message class above.
+    LocaleHandler takes a locale and a target logging.Handler object
+    to forward LogRecord objects to after translating the internal Message.
+    """
+
+    def __init__(self, locale, target):
+        """Initialize a LocaleHandler
+
+        :param locale: locale to use for translating messages
+        :param target: logging.Handler object to forward
+                       LogRecord objects to after translation
+        """
+        logging.Handler.__init__(self)
+        self.locale = locale
+        self.target = target
+
+    def emit(self, record):
+        if isinstance(record.msg, Message):
+            # set the locale and resolve to a string
+            record.msg.locale = self.locale
+
+        self.target.emit(record)

seamicroclient/openstack/common/py3kcompat/__init__.py

@@ -0,0 +1,17 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+#
+# Copyright 2013 Canonical Ltd.
+# 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.
+#

seamicroclient/openstack/common/py3kcompat/urlutils.py

@@ -0,0 +1,49 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+#
+# Copyright 2013 Canonical Ltd.
+# 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.
+#
+
+"""
+Python2/Python3 compatibility layer for OpenStack
+"""
+
+import six
+
+if six.PY3:
+    # python3
+    import urllib.parse
+
+    urlencode = urllib.parse.urlencode
+    urljoin = urllib.parse.urljoin
+    quote = urllib.parse.quote
+    parse_qsl = urllib.parse.parse_qsl
+    urlparse = urllib.parse.urlparse
+    urlsplit = urllib.parse.urlsplit
+    urlunsplit = urllib.parse.urlunsplit
+else:
+    # python2
+    import urllib
+    import urlparse
+
+    urlencode = urllib.urlencode
+    quote = urllib.quote
+
+    parse = urlparse
+    parse_qsl = parse.parse_qsl
+    urljoin = parse.urljoin
+    urlparse = parse.urlparse
+    urlsplit = parse.urlsplit
+    urlunsplit = parse.urlunsplit

seamicroclient/openstack/common/strutils.py

@@ -0,0 +1,218 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack Foundation.
+# 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.
+
+"""
+System-level utilities and helper functions.
+"""
+
+import re
+import sys
+import unicodedata
+
+import six
+
+from seamicroclient.openstack.common.gettextutils import _  # noqa
+
+
+# Used for looking up extensions of text
+# to their 'multiplied' byte amount
+BYTE_MULTIPLIERS = {
+    '': 1,
+    't': 1024 ** 4,
+    'g': 1024 ** 3,
+    'm': 1024 ** 2,
+    'k': 1024,
+}
+BYTE_REGEX = re.compile(r'(^-?\d+)(\D*)')
+
+TRUE_STRINGS = ('1', 't', 'true', 'on', 'y', 'yes')
+FALSE_STRINGS = ('0', 'f', 'false', 'off', 'n', 'no')
+
+SLUGIFY_STRIP_RE = re.compile(r"[^\w\s-]")
+SLUGIFY_HYPHENATE_RE = re.compile(r"[-\s]+")
+
+
+def int_from_bool_as_string(subject):
+    """Interpret a string as a boolean and return either 1 or 0.
+
+    Any string value in:
+
+        ('True', 'true', 'On', 'on', '1')
+
+    is interpreted as a boolean True.
+
+    Useful for JSON-decoded stuff and config file parsing
+    """
+    return bool_from_string(subject) and 1 or 0
+
+
+def bool_from_string(subject, strict=False):
+    """Interpret a string as a boolean.
+
+    A case-insensitive match is performed such that strings matching 't',
+    'true', 'on', 'y', 'yes', or '1' are considered True and, when
+    `strict=False`, anything else is considered False.
+
+    Useful for JSON-decoded stuff and config file parsing.
+
+    If `strict=True`, unrecognized values, including None, will raise a
+    ValueError which is useful when parsing values passed in from an API call.
+    Strings yielding False are 'f', 'false', 'off', 'n', 'no', or '0'.
+    """
+    if not isinstance(subject, six.string_types):
+        subject = str(subject)
+
+    lowered = subject.strip().lower()
+
+    if lowered in TRUE_STRINGS:
+        return True
+    elif lowered in FALSE_STRINGS:
+        return False
+    elif strict:
+        acceptable = ', '.join(
+            "'%s'" % s for s in sorted(TRUE_STRINGS + FALSE_STRINGS))
+        msg = _("Unrecognized value '%(val)s', acceptable values are:"
+                " %(acceptable)s") % {'val': subject,
+                                      'acceptable': acceptable}
+        raise ValueError(msg)
+    else:
+        return False
+
+
+def safe_decode(text, incoming=None, errors='strict'):
+    """Decodes incoming str using `incoming` if they're not already unicode.
+
+    :param incoming: Text's current encoding
+    :param errors: Errors handling policy. See here for valid
+        values http://docs.python.org/2/library/codecs.html
+    :returns: text or a unicode `incoming` encoded
+                representation of it.
+    :raises TypeError: If text is not an isntance of str
+    """
+    if not isinstance(text, six.string_types):
+        raise TypeError("%s can't be decoded" % type(text))
+
+    if isinstance(text, six.text_type):
+        return text
+
+    if not incoming:
+        incoming = (sys.stdin.encoding or
+                    sys.getdefaultencoding())
+
+    try:
+        return text.decode(incoming, errors)
+    except UnicodeDecodeError:
+        # Note(flaper87) If we get here, it means that
+        # sys.stdin.encoding / sys.getdefaultencoding
+        # didn't return a suitable encoding to decode
+        # text. This happens mostly when global LANG
+        # var is not set correctly and there's no
+        # default encoding. In this case, most likely
+        # python will use ASCII or ANSI encoders as
+        # default encodings but they won't be capable
+        # of decoding non-ASCII characters.
+        #
+        # Also, UTF-8 is being used since it's an ASCII
+        # extension.
+        return text.decode('utf-8', errors)
+
+
+def safe_encode(text, incoming=None,
+                encoding='utf-8', errors='strict'):
+    """Encodes incoming str/unicode using `encoding`.
+
+    If incoming is not specified, text is expected to be encoded with
+    current python's default encoding. (`sys.getdefaultencoding`)
+
+    :param incoming: Text's current encoding
+    :param encoding: Expected encoding for text (Default UTF-8)
+    :param errors: Errors handling policy. See here for valid
+        values http://docs.python.org/2/library/codecs.html
+    :returns: text or a bytestring `encoding` encoded
+                representation of it.
+    :raises TypeError: If text is not an isntance of str
+    """
+    if not isinstance(text, six.string_types):
+        raise TypeError("%s can't be encoded" % type(text))
+
+    if not incoming:
+        incoming = (sys.stdin.encoding or
+                    sys.getdefaultencoding())
+
+    if isinstance(text, six.text_type):
+        return text.encode(encoding, errors)
+    elif text and encoding != incoming:
+        # Decode text before encoding it with `encoding`
+        text = safe_decode(text, incoming, errors)
+        return text.encode(encoding, errors)
+
+    return text
+
+
+def to_bytes(text, default=0):
+    """Converts a string into an integer of bytes.
+
+    Looks at the last characters of the text to determine
+    what conversion is needed to turn the input text into a byte number.
+    Supports "B, K(B), M(B), G(B), and T(B)". (case insensitive)
+
+    :param text: String input for bytes size conversion.
+    :param default: Default return value when text is blank.
+
+    """
+    match = BYTE_REGEX.search(text)
+    if match:
+        magnitude = int(match.group(1))
+        mult_key_org = match.group(2)
+        if not mult_key_org:
+            return magnitude
+    elif text:
+        msg = _('Invalid string format: %s') % text
+        raise TypeError(msg)
+    else:
+        return default
+    mult_key = mult_key_org.lower().replace('b', '', 1)
+    multiplier = BYTE_MULTIPLIERS.get(mult_key)
+    if multiplier is None:
+        msg = _('Unknown byte multiplier: %s') % mult_key_org
+        raise TypeError(msg)
+    return magnitude * multiplier
+
+
+def to_slug(value, incoming=None, errors="strict"):
+    """Normalize string.
+
+    Convert to lowercase, remove non-word characters, and convert spaces
+    to hyphens.
+
+    Inspired by Django's `slugify` filter.
+
+    :param value: Text to slugify
+    :param incoming: Text's current encoding
+    :param errors: Errors handling policy. See here for valid
+        values http://docs.python.org/2/library/codecs.html
+    :returns: slugified unicode representation of `value`
+    :raises TypeError: If text is not an instance of str
+    """
+    value = safe_decode(value, incoming, errors)
+    # NOTE(aababilov): no need to use safe_(encode|decode) here:
+    # encodings are always "ascii", error handling is always "ignore"
+    # and types are always known (first: unicode; second: str)
+    value = unicodedata.normalize("NFKD", value).encode(
+        "ascii", "ignore").decode("ascii")
+    value = SLUGIFY_STRIP_RE.sub("", value).strip().lower()
+    return SLUGIFY_HYPHENATE_RE.sub("-", value)

seamicroclient/openstack/common/timeutils.py

@@ -0,0 +1,194 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 OpenStack Foundation.
+# 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.
+
+"""
+Time related utilities and helper functions.
+"""
+
+import calendar
+import datetime
+import time
+
+import iso8601
+import six
+
+
+# ISO 8601 extended time format with microseconds
+_ISO8601_TIME_FORMAT_SUBSECOND = '%Y-%m-%dT%H:%M:%S.%f'
+_ISO8601_TIME_FORMAT = '%Y-%m-%dT%H:%M:%S'
+PERFECT_TIME_FORMAT = _ISO8601_TIME_FORMAT_SUBSECOND
+
+
+def isotime(at=None, subsecond=False):
+    """Stringify time in ISO 8601 format."""
+    if not at:
+        at = utcnow()
+    st = at.strftime(_ISO8601_TIME_FORMAT
+                     if not subsecond
+                     else _ISO8601_TIME_FORMAT_SUBSECOND)
+    tz = at.tzinfo.tzname(None) if at.tzinfo else 'UTC'
+    st += ('Z' if tz == 'UTC' else tz)
+    return st
+
+
+def parse_isotime(timestr):
+    """Parse time from ISO 8601 format."""
+    try:
+        return iso8601.parse_date(timestr)
+    except iso8601.ParseError as e:
+        raise ValueError(unicode(e))
+    except TypeError as e:
+        raise ValueError(unicode(e))
+
+
+def strtime(at=None, fmt=PERFECT_TIME_FORMAT):
+    """Returns formatted utcnow."""
+    if not at:
+        at = utcnow()
+    return at.strftime(fmt)
+
+
+def parse_strtime(timestr, fmt=PERFECT_TIME_FORMAT):
+    """Turn a formatted time back into a datetime."""
+    return datetime.datetime.strptime(timestr, fmt)
+
+
+def normalize_time(timestamp):
+    """Normalize time in arbitrary timezone to UTC naive object."""
+    offset = timestamp.utcoffset()
+    if offset is None:
+        return timestamp
+    return timestamp.replace(tzinfo=None) - offset
+
+
+def is_older_than(before, seconds):
+    """Return True if before is older than seconds."""
+    if isinstance(before, six.string_types):
+        before = parse_strtime(before).replace(tzinfo=None)
+    return utcnow() - before > datetime.timedelta(seconds=seconds)
+
+
+def is_newer_than(after, seconds):
+    """Return True if after is newer than seconds."""
+    if isinstance(after, six.string_types):
+        after = parse_strtime(after).replace(tzinfo=None)
+    return after - utcnow() > datetime.timedelta(seconds=seconds)
+
+
+def utcnow_ts():
+    """Timestamp version of our utcnow function."""
+    if utcnow.override_time is None:
+        # NOTE(kgriffs): This is several times faster
+        # than going through calendar.timegm(...)
+        return int(time.time())
+
+    return calendar.timegm(utcnow().timetuple())
+
+
+def utcnow():
+    """Overridable version of utils.utcnow."""
+    if utcnow.override_time:
+        try:
+            return utcnow.override_time.pop(0)
+        except AttributeError:
+            return utcnow.override_time
+    return datetime.datetime.utcnow()
+
+
+def iso8601_from_timestamp(timestamp):
+    """Returns a iso8601 formated date from timestamp."""
+    return isotime(datetime.datetime.utcfromtimestamp(timestamp))
+
+
+utcnow.override_time = None
+
+
+def set_time_override(override_time=datetime.datetime.utcnow()):
+    """Overrides utils.utcnow.
+
+    Make it return a constant time or a list thereof, one at a time.
+    """
+    utcnow.override_time = override_time
+
+
+def advance_time_delta(timedelta):
+    """Advance overridden time using a datetime.timedelta."""
+    assert(not utcnow.override_time is None)
+    try:
+        for dt in utcnow.override_time:
+            dt += timedelta
+    except TypeError:
+        utcnow.override_time += timedelta
+
+
+def advance_time_seconds(seconds):
+    """Advance overridden time by seconds."""
+    advance_time_delta(datetime.timedelta(0, seconds))
+
+
+def clear_time_override():
+    """Remove the overridden time."""
+    utcnow.override_time = None
+
+
+def marshall_now(now=None):
+    """Make an rpc-safe datetime with microseconds.
+
+    Note: tzinfo is stripped, but not required for relative times.
+    """
+    if not now:
+        now = utcnow()
+    return dict(day=now.day, month=now.month, year=now.year, hour=now.hour,
+                minute=now.minute, second=now.second,
+                microsecond=now.microsecond)
+
+
+def unmarshall_time(tyme):
+    """Unmarshall a datetime dict."""
+    return datetime.datetime(day=tyme['day'],
+                             month=tyme['month'],
+                             year=tyme['year'],
+                             hour=tyme['hour'],
+                             minute=tyme['minute'],
+                             second=tyme['second'],
+                             microsecond=tyme['microsecond'])
+
+
+def delta_seconds(before, after):
+    """Return the difference between two timing objects.
+
+    Compute the difference in seconds between two date, time, or
+    datetime objects (as a float, to microsecond resolution).
+    """
+    delta = after - before
+    try:
+        return delta.total_seconds()
+    except AttributeError:
+        return ((delta.days * 24 * 3600) + delta.seconds +
+                float(delta.microseconds) / (10 ** 6))
+
+
+def is_soon(dt, window):
+    """Determines if time is going to happen in the next window seconds.
+
+    :params dt: the time
+    :params window: minimum seconds to remain to consider the time not soon
+
+    :return: True if expiration is within the given duration
+    """
+    soon = (utcnow() + datetime.timedelta(seconds=window))
+    return normalize_time(dt) <= soon

seamicroclient/openstack/common/uuidutils.py

@@ -0,0 +1,39 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2012 Intel Corporation.
+# 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.
+
+"""
+UUID related utilities and helper functions.
+"""
+
+import uuid
+
+
+def generate_uuid():
+    return str(uuid.uuid4())
+
+
+def is_uuid_like(val):
+    """Returns validation of a value as a UUID.
+
+    For our purposes, a UUID is a canonical form string:
+    aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa
+
+    """
+    try:
+        return str(uuid.UUID(val)) == val
+    except (TypeError, ValueError, AttributeError):
+        return False

seamicroclient/tests/fakes.py

@@ -0,0 +1,93 @@
+#
+#    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.
+
+"""
+A fake server that "responds" to API methods with pre-canned responses.
+
+All of these responses come from the spec, so if for some reason the spec's
+wrong the tests might raise AssertionError. I've indicated in comments the
+places where actual behavior differs from the spec.
+"""
+
+from seamicroclient import base
+
+
+def assert_has_keys(dict, required=[], optional=[]):
+    keys = dict.keys()
+    for k in required:
+        try:
+            assert k in keys
+        except AssertionError:
+            extra_keys = set(keys).difference(set(required + optional))
+            raise AssertionError("found unexpected keys: %s" %
+                                 list(extra_keys))
+
+
+class FakeClient(object):
+
+    def assert_called(self, method, url, body=None, pos=-1):
+        """
+        Assert than an API method was just called.
+        """
+        expected = (method, url)
+        called = self.client.callstack[pos][0:2]
+
+        assert self.client.callstack, \
+            "Expected %s %s but no calls were made." % expected
+
+        assert expected == called, 'Expected %s %s; got %s %s' % \
+            (expected + called)
+
+        if body is not None:
+            if self.client.callstack[pos][2] != body:
+                raise AssertionError('%r != %r' %
+                                     (self.client.callstack[pos][2], body))
+
+    def assert_called_anytime(self, method, url, body=None):
+        """
+        Assert than an API method was called anytime in the test.
+        """
+        expected = (method, url)
+
+        assert self.client.callstack, \
+            "Expected %s %s but no calls were made." % expected
+
+        found = False
+        for entry in self.client.callstack:
+            if expected == entry[0:2]:
+                found = True
+                break
+
+        assert found, 'Expected %s; got %s' % \
+            (expected, self.client.callstack)
+        if body is not None:
+            try:
+                assert entry[2] == body
+            except AssertionError:
+                print(entry[2])
+                print("!=")
+                print(body)
+                raise
+
+        self.client.callstack = []
+
+    def clear_callstack(self):
+        self.client.callstack = []
+
+    def authenticate(self):
+        pass
+
+
+# Fake class that will be used as an extension
+class FakeManager(base.Manager):
+    pass

seamicroclient/tests/test_base.py

@@ -0,0 +1,58 @@
+#
+#    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 seamicroclient import base
+from seamicroclient.tests import utils
+from seamicroclient.tests.v2 import fakes
+from seamicroclient.v2 import servers
+
+
+cs = fakes.FakeClient()
+
+
+class BaseTest(utils.TestCase):
+
+    def test_resource_repr(self):
+        r = base.Resource(None, dict(foo="bar", baz="spam"))
+        self.assertEqual(repr(r), "<Resource baz=spam, foo=bar>")
+
+    def test_getid(self):
+        self.assertEqual(base.getid(4), 4)
+
+        class TmpObject(object):
+            id = 4
+        self.assertEqual(base.getid(TmpObject), 4)
+
+    def test_resource_lazy_getattr(self):
+        f = servers.Server(cs.servers, {'id': 1})
+        self.assertEqual(f.name, 'sample-server')
+        cs.assert_called('GET', '/servers/1')
+
+        # Missing stuff still fails after a second get
+        self.assertRaises(AttributeError, getattr, f, 'blahblah')
+
+    def test_eq(self):
+        # Two resources of the same type with the same id: equal
+        r1 = base.Resource(None, {'id': 1, 'name': 'hi'})
+        r2 = base.Resource(None, {'id': 1, 'name': 'hello'})
+        self.assertEqual(r1, r2)
+
+        # Two resoruces of different types: never equal
+        r1 = base.Resource(None, {'id': 1})
+        r2 = servers.Server(None, {'id': 1})
+        self.assertNotEqual(r1, r2)
+
+        # Two resources with no ID: equal if their info is equal
+        r1 = base.Resource(None, {'name': 'joe', 'age': 12})
+        r2 = base.Resource(None, {'name': 'joe', 'age': 12})
+        self.assertEqual(r1, r2)

seamicroclient/tests/test_client.py

@@ -0,0 +1,42 @@
+# Copyright 2012 OpenStack Foundation
+# 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 mock
+
+import seamicroclient.client
+from seamicroclient.tests import utils
+import seamicroclient.v2.client
+
+
+class ClientTest(utils.TestCase):
+
+    def test_client_with_timeout(self):
+        instance = seamicroclient.client.HTTPClient(user='user',
+                                                    password='password',
+                                                    timeout=2,
+                                                    auth_url="http://www.blah.com/login")
+        self.assertEqual(instance.timeout, 2)
+
+    def test_get_client_class_v2(self):
+        output = seamicroclient.client.get_client_class('2')
+        self.assertEqual(output, seamicroclient.v2.client.Client)
+
+    @mock.patch.object(seamicroclient.client.HTTPClient, 'authenticate')
+    def test_authenticate_call_v2(self, mock_authenticate):
+        cs = seamicroclient.v2.client.Client("user", "password",
+                                             auth_url="foo/v2")
+        cs.authenticate()
+        self.assertTrue(mock_authenticate.called)

seamicroclient/tests/test_http.py

@@ -0,0 +1,131 @@
+#
+#    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 json
+
+import mock
+import requests
+
+
+from seamicroclient import client
+from seamicroclient import exceptions
+from seamicroclient.tests import utils
+
+
+fake_response = utils.TestResponse({
+    "status_code": 200,
+    "text": '{"hi": "there"}',
+})
+mock_request = mock.Mock(return_value=(fake_response))
+
+refused_response = utils.TestResponse({
+    "status_code": 400,
+    "text": '[Errno 111] Connection refused',
+})
+refused_mock_request = mock.Mock(return_value=(refused_response))
+
+bad_req_response = utils.TestResponse({
+    "status_code": 400,
+    "text": '',
+})
+bad_req_mock_request = mock.Mock(return_value=(bad_req_response))
+
+
+def get_client():
+    cl = client.HTTPClient("username", "password", "http://example.com/login")
+    return cl
+
+
+def get_authed_client():
+    cl = get_client()
+    cl.auth_url = "http://example.com/login"
+    cl.auth_token = "token"
+    return cl
+
+
+class ClientTest(utils.TestCase):
+
+    def test_get(self):
+        cl = get_authed_client()
+
+        @mock.patch.object(requests.Session, "request", mock_request)
+        @mock.patch('time.time', mock.Mock(return_value=1234))
+        def test_get_call():
+            resp, body = cl.get("/hi")
+            headers = {'Accept': 'application/json',
+                       'User-Agent': 'python-seamicroclient'}
+            mock_request.assert_called_with(
+                "GET",
+                "http://example.com/hi?authtoken=%s" % cl.auth_token,
+                headers=headers)
+            # Automatic JSON parsing
+            self.assertEqual(body, {"hi": "there"})
+
+        test_get_call()
+
+    def test_post(self):
+        cl = get_authed_client()
+
+        @mock.patch.object(requests.Session, "request", mock_request)
+        def test_post_call():
+            body = {'k1': 'v1', 'k2': 'v2', 'authtoken': cl.auth_token}
+            cl.post("/hi", body=body)
+            headers = {'Content-Type': 'application/json', 'Accept':
+                       'application/json',
+                       'User-Agent': 'python-seamicroclient'}
+            mock_request.assert_called_with(
+                "POST",
+                "http://example.com/hi",
+                headers=headers,
+                data=json.dumps(body))
+
+        test_post_call()
+
+    def test_auth_failure(self):
+        cl = get_client()
+
+        # response must not have x-server-management-url header
+        @mock.patch.object(requests.Session, "request", mock_request)
+        def test_auth_call():
+            self.assertRaises(exceptions.AuthorizationFailure, cl.authenticate)
+
+        test_auth_call()
+
+    def test_connection_refused(self):
+        cl = get_client()
+
+        @mock.patch.object(requests.Session, "request", refused_mock_request)
+        def test_refused_call():
+            self.assertRaises(exceptions.ConnectionRefused, cl.get, "/hi")
+
+        test_refused_call()
+
+    def test_bad_request(self):
+        cl = get_client()
+
+        @mock.patch.object(requests.Session, "request", bad_req_mock_request)
+        def test_refused_call():
+            self.assertRaises(exceptions.BadRequest, cl.get, "/hi")
+
+        test_refused_call()
+
+    def test_client_logger(self):
+        cl1 = client.HTTPClient("username", "password",
+                                "http://example.com/login",
+                                http_log_debug=True)
+        self.assertEqual(len(cl1._logger.handlers), 1)
+
+        cl2 = client.HTTPClient("username", "password",
+                                "http://example.com/login",
+                                http_log_debug=True)
+        self.assertEqual(len(cl2._logger.handlers), 1)

seamicroclient/tests/utils.py

@@ -0,0 +1,58 @@
+#
+#    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 os
+
+import fixtures
+import requests
+import testtools
+
+
+class TestCase(testtools.TestCase):
+
+    def setUp(self):
+        super(TestCase, self).setUp()
+        if (os.environ.get('OS_STDOUT_CAPTURE') == 'True' or
+                os.environ.get('OS_STDOUT_CAPTURE') == '1'):
+            stdout = self.useFixture(fixtures.StringStream('stdout')).stream
+            self.useFixture(fixtures.MonkeyPatch('sys.stdout', stdout))
+        if (os.environ.get('OS_STDERR_CAPTURE') == 'True' or
+                os.environ.get('OS_STDERR_CAPTURE') == '1'):
+            stderr = self.useFixture(fixtures.StringStream('stderr')).stream
+            self.useFixture(fixtures.MonkeyPatch('sys.stderr', stderr))
+
+
+class TestResponse(requests.Response):
+
+    """
+    Class used to wrap requests.Response and provide some
+    convenience to initialize with a dict
+    """
+
+    def __init__(self, data):
+        self._text = None
+        super(TestResponse, self)
+        if isinstance(data, dict):
+            self.status_code = data.get('status_code', None)
+            self.headers = data.get('headers', None)
+            # Fake the text attribute to streamline Response creation
+            self._text = data.get('text', None)
+        else:
+            self.status_code = data
+
+    def __eq__(self, other):
+        return self.__dict__ == other.__dict__
+
+    @property
+    def text(self):
+        return self._text

seamicroclient/tests/v2/fakes.py

@@ -0,0 +1,98 @@
+# 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 seamicroclient import client as base_client
+from seamicroclient.openstack.common.py3kcompat import urlutils
+from seamicroclient.tests import fakes
+from seamicroclient.tests import utils
+from seamicroclient.v2 import client
+
+
+class FakeClient(fakes.FakeClient, client.Client):
+
+    def __init__(self, *args, **kwargs):
+        client.Client.__init__(self, 'username', 'password',
+                               'auth_url')
+        self.client = FakeHTTPClient(**kwargs)
+
+
+class FakeHTTPClient(base_client.HTTPClient):
+
+    def __init__(self, **kwargs):
+        self.username = 'username'
+        self.password = 'password'
+        self.auth_url = 'auth_url'
+        self.callstack = []
+        self.timings = 'timings'
+        self.http_log_debug = 'http_log_debug'
+
+    def _cs_request(self, url, method, **kwargs):
+        # Check that certain things are called correctly
+        if method in ['GET', 'DELETE']:
+            assert 'body' not in kwargs
+        elif method == 'PUT':
+            assert 'body' in kwargs
+
+        # Call the method
+        args = urlutils.parse_qsl(urlutils.urlparse(url)[4])
+        kwargs.update(args)
+        munged_url = url.rsplit('?', 1)[0]
+        munged_url = munged_url.strip('/').replace('/', '_').replace('.', '_')
+        munged_url = munged_url.replace('-', '_')
+        munged_url = munged_url.replace(' ', '_')
+
+        callback = "%s_%s" % (method.lower(), munged_url)
+
+        if not hasattr(self, callback):
+            raise AssertionError('Called unknown API method: %s %s, '
+                                 'expected fakes method name: %s' %
+                                 (method, url, callback))
+
+        # Note the call
+        self.callstack.append((method, url, kwargs.get('body', None)))
+
+        status, headers, body = getattr(self, callback)(**kwargs)
+        r = utils.TestResponse({
+            "status_code": status,
+            "text": body,
+            "headers": headers,
+        })
+        return r, body
+
+    def get_servers_1(self, **kwargs):
+        return (200, {}, {'id': 1234, 'name': 'sample-server'}
+                )
+
+    def get_servers(self, **kwargs):
+        return (200, {}, {'0/0': {}, '1/0': {}})
+
+    def put_servers_1(self, **kwargs):
+        return (200, {}, {})
+
+    def get_storage_pools(self):
+        return (200, {}, {'0/p0-0': {}, '0/p1-1': {}})
+
+    def get_storage_pools_1(self):
+        return (200, {}, {'0/p0-0': {}})
+
+    def get_storage_volumes(self):
+        return (200, {}, {'0/p0-0/1': {}, '0/p1-1/1': {}})
+
+    def get_storage_volumes_1(self):
+        return (200, {}, {'1': {}})
+
+    def put_storage_volumes_0_p0_0_1(self, **kwargs):
+        return (200, {}, {'0/p0-0/1': {}})
+
+    def get_storage_volumes_0_p0_0_1(self, **kwargs):
+        return (200, {}, {'0/p0-0/1': {}})

seamicroclient/tests/v2/test_pools.py

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+#
+#    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 seamicroclient.tests import utils
+from seamicroclient.tests.v2 import fakes
+from seamicroclient.v2 import pools
+
+
+cs = fakes.FakeClient()
+
+
+class PoolsTest(utils.TestCase):
+
+    def test_list_pools(self):
+        pl = cs.pools.list()
+        cs.assert_called('GET', '/storage/pools')
+        [self.assertTrue(isinstance(s, pools.Pool)) for s in pl]
+
+    def test_get_pool(self):
+        p = cs.pools.get(1)
+        cs.assert_called('GET', '/storage/pools/1')
+        self.assertTrue(isinstance(p, pools.Pool))

seamicroclient/tests/v2/test_servers.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+#
+#    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 seamicroclient.tests import utils
+from seamicroclient.tests.v2 import fakes
+from seamicroclient.v2 import servers
+
+
+cs = fakes.FakeClient()
+
+
+class ServersTest(utils.TestCase):
+
+    def test_list_servers(self):
+        sl = cs.servers.list()
+        cs.assert_called('GET', '/servers')
+        [self.assertTrue(isinstance(s, servers.Server)) for s in sl]
+
+    def test_get_server(self):
+        s = cs.servers.get(1)
+        cs.assert_called('GET', '/servers/1')
+        self.assertTrue(isinstance(s, servers.Server))
+
+    def test_server_power_on(self):
+        cs.servers.power_on(1)
+        cs.assert_called('PUT', '/servers/1')
+
+    def test_server_power_off(self):
+        cs.servers.power_off(1)
+        cs.assert_called('PUT', '/servers/1')
+
+    def test_server_reset(self):
+        cs.servers.reset(1)
+        cs.assert_called('PUT', '/servers/1')
+
+    def test_server_set_tagged_vlan(self):
+        cs.servers.set_tagged_vlan(1, '12-12')
+        cs.assert_called('PUT', '/servers/1')
+
+    def test_server_unset_tagged_vlan(self):
+        cs.servers.unset_tagged_vlan(1, '12-12')
+        cs.assert_called('PUT', '/servers/1')
+
+    def test_server_set_untagged_vlan(self):
+        cs.servers.set_untagged_vlan(1, '12-12')
+        cs.assert_called('PUT', '/servers/1')
+
+    def test_server_unset_untagged_vlan(self):
+        cs.servers.unset_untagged_vlan(1, '12-12')
+        cs.assert_called('PUT', '/servers/1')

seamicroclient/tests/v2/test_volumes.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+#
+#    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 seamicroclient.tests import utils
+from seamicroclient.tests.v2 import fakes
+from seamicroclient.v2 import volumes
+
+
+cs = fakes.FakeClient()
+
+
+class VolumesTest(utils.TestCase):
+
+    def test_list_volumes(self):
+        vl = cs.volumes.list()
+        cs.assert_called('GET', '/storage/volumes')
+        [self.assertTrue(isinstance(s, volumes.Volume)) for s in vl]
+
+    def test_get_volume(self):
+        p = cs.volumes.get(1)
+        cs.assert_called('GET', '/storage/volumes/1')
+        self.assertTrue(isinstance(p, volumes.Volume))
+
+    def test_create_volume(self):
+        v = cs.volumes.create('1', '0/p0_0', 2)
+        cs.assert_called('PUT', '/storage/volumes/0/p0_0/1')
+        self.assertTrue(isinstance(v, volumes.Volume))

seamicroclient/utils.py

@@ -0,0 +1,175 @@
+#
+#    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 os
+import pkg_resources
+import sys
+import uuid
+
+import six
+
+from seamicroclient import exceptions
+from seamicroclient.openstack.common import strutils
+
+
+def env(*args, **kwargs):
+    """
+    returns the first environment variable set
+    if none are non-empty, defaults to '' or keyword arg default
+    """
+    for arg in args:
+        value = os.environ.get(arg, None)
+        if value:
+            return value
+    return kwargs.get('default', '')
+
+
+def find_resource(manager, name_or_id, **find_args):
+    """Helper for the _find_* methods."""
+    # first try to get entity as integer id
+    try:
+        return manager.get(int(name_or_id))
+    except (TypeError, ValueError, exceptions.NotFound):
+        pass
+
+    # now try to get entity as uuid
+    try:
+        tmp_id = strutils.safe_encode(name_or_id)
+        if six.PY3:
+            tmp_id = tmp_id.decode()
+        uuid.UUID(tmp_id)
+        return manager.get(tmp_id)
+    except (TypeError, ValueError, exceptions.NotFound):
+        pass
+
+    # for str id which is not uuid (for Flavor search currently)
+    if getattr(manager, 'is_alphanum_id_allowed', False):
+        try:
+            return manager.get(name_or_id)
+        except exceptions.NotFound:
+            pass
+
+    try:
+        try:
+            return manager.find(human_id=name_or_id, **find_args)
+        except exceptions.NotFound:
+            pass
+
+        # finally try to find entity by name
+        try:
+            resource = getattr(manager, 'resource_class', None)
+            name_attr = resource.NAME_ATTR if resource else 'name'
+            kwargs = {name_attr: name_or_id}
+            kwargs.update(find_args)
+            return manager.find(**kwargs)
+        except exceptions.NotFound:
+            msg = "No %s with a name or ID of '%s' exists." % \
+                (manager.resource_class.__name__.lower(), name_or_id)
+            raise exceptions.CommandError(msg)
+    except exceptions.NoUniqueMatch:
+        msg = ("Multiple %s matches found for '%s', use an ID to be more"
+               " specific." % (manager.resource_class.__name__.lower(),
+                               name_or_id))
+        raise exceptions.CommandError(msg)
+
+
+def _format_field_name(attr):
+    """Format an object attribute in a human-friendly way."""
+    # Split at ':' and leave the extension name as-is.
+    parts = attr.rsplit(':', 1)
+    name = parts[-1].replace('_', ' ')
+    # Don't title() on mixed case
+    if name.isupper() or name.islower():
+        name = name.title()
+    parts[-1] = name
+    return ': '.join(parts)
+
+
+def _make_field_formatter(attr, filters=None):
+    """
+    Given an object attribute, return a formatted field name and a
+    formatter suitable for passing to print_list.
+
+    Optionally pass a dict mapping attribute names to a function. The function
+    will be passed the value of the attribute and should return the string to
+    display.
+    """
+    filter_ = None
+    if filters:
+        filter_ = filters.get(attr)
+
+    def get_field(obj):
+        field = getattr(obj, attr, '')
+        if field and filter_:
+            field = filter_(field)
+        return field
+
+    name = _format_field_name(attr)
+    formatter = get_field
+    return name, formatter
+
+
+class HookableMixin(object):
+
+    """Mixin so classes can register and run hooks."""
+    _hooks_map = {}
+
+    @classmethod
+    def add_hook(cls, hook_type, hook_func):
+        if hook_type not in cls._hooks_map:
+            cls._hooks_map[hook_type] = []
+
+        cls._hooks_map[hook_type].append(hook_func)
+
+    @classmethod
+    def run_hooks(cls, hook_type, *args, **kwargs):
+        hook_funcs = cls._hooks_map.get(hook_type) or []
+        for hook_func in hook_funcs:
+            hook_func(*args, **kwargs)
+
+
+def safe_issubclass(*args):
+    """Like issubclass, but will just return False if not a class."""
+
+    try:
+        if issubclass(*args):
+            return True
+    except TypeError:
+        pass
+
+    return False
+
+
+def import_class(import_str):
+    """Returns a class from a string including module and class."""
+    mod_str, _sep, class_str = import_str.rpartition('.')
+    __import__(mod_str)
+    return getattr(sys.modules[mod_str], class_str)
+
+
+def _load_entry_point(ep_name, name=None):
+    """Try to load the entry point ep_name that matches name."""
+    for ep in pkg_resources.iter_entry_points(ep_name, name=name):
+        try:
+            return ep.load()
+        except (ImportError, pkg_resources.UnknownExtra, AttributeError):
+            continue
+
+
+def is_integer_like(val):
+    """Returns validation of a value as an integer."""
+    try:
+        value = int(val)
+        return True
+    except (TypeError, ValueError, AttributeError):
+        return False

seamicroclient/v2/__init__.py

@@ -0,0 +1,13 @@
+#    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 seamicroclient.v2.client import Client   # noqa

seamicroclient/v2/client.py

@@ -0,0 +1,66 @@
+# 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 seamicroclient import client
+from seamicroclient.v2 import servers
+from seamicroclient.v2 import pools
+from seamicroclient.v2 import volumes
+
+
+class Client(object):
+
+    """
+    Top-level object to access the Seamicro Chassis API.
+
+    Create an instance with your creds::
+
+        >>> client = Client(USERNAME, PASSWORD, AUTH_URL)
+
+    Then call methods on its managers::
+
+        >>> client.servers.list()
+        ...
+        >>> client.chassis.list()
+        ...
+
+    """
+
+    def __init__(self, username, password, auth_url=None,
+                 timeout=None, http_log_debug=False):
+        self.servers = servers.ServerManager(self)
+        self.pools = pools.PoolManager(self)
+        self.volumes = volumes.VolumeManager(self)
+
+        self.client = client.HTTPClient(username,
+                                        password,
+                                        auth_url=auth_url,
+                                        timeout=timeout,
+                                        http_log_debug=http_log_debug)
+
+    def get_timings(self):
+        return self.client.get_timings()
+
+    def reset_timings(self):
+        self.client.reset_timings()
+
+    def authenticate(self):
+        """
+        Authenticate against the server.
+
+        Normally this is called automatically when you first access the API,
+        but you can call this method to force authentication right now.
+
+        Returns on success; raises :exc:`exceptions.Unauthorized` if the
+        credentials are wrong.
+        """
+        self.client.authenticate()

seamicroclient/v2/pools.py

@@ -0,0 +1,57 @@
+#    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.
+
+"""
+Pool interface.
+"""
+
+
+from seamicroclient import base
+
+
+class Pool(base.Resource):
+    HUMAN_ID = True
+
+    def __repr__(self):
+        return "<Pool: %s>" % self.id
+
+
+class PoolManager(base.ManagerWithFind):
+    resource_class = Pool
+
+    def get(self, pool):
+        """
+        Get a pool.
+
+        :param pool: ID of the :class:`Pool` to get.
+        :rtype: :class:`Pool`
+        """
+        return self._get(base.getid(pool),
+                         "/storage/pools/%s" % base.getid(pool))
+
+    def list(self):
+        """
+        Get a list of pools.
+
+        :rtype: list of :class:`Pool`
+        """
+        return self._list("/storage/pools")
+
+    def _action(self, action, pool, info=None, **kwargs):
+        """
+        Perform a pool "action" -- .
+        """
+        body = {"action": action}
+        body.update(info)
+        self.run_hooks('modify_body_for_action', body, **kwargs)
+        url = '/storage/pools/%s' % base.getid(pool)
+        return self.api.client.put(url, body=body)

seamicroclient/v2/servers.py

@@ -0,0 +1,156 @@
+#    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.
+
+"""
+Server interface.
+"""
+
+
+from seamicroclient import base
+
+
+class Server(base.Resource):
+    HUMAN_ID = True
+
+    def __repr__(self):
+        return "<Server: %s>" % self.id
+
+    def power_on(self, using_pxe=False):
+        self.manager.power_on(self, using_pxe)
+
+    def power_off(self, force=False):
+        self.manager.power_off(self, force)
+
+    def reset(self, using_pxe=False):
+        self.manager.reset(self, using_pxe)
+
+
+class ServerManager(base.ManagerWithFind):
+    resource_class = Server
+
+    def get(self, server):
+        """
+        Get a server.
+
+        :param server: ID of the :class:`Server` to get.
+        :rtype: :class:`Server`
+        """
+        return self._get(base.getid(server),
+                         "/servers/%s" % base.getid(server))
+
+    def list(self):
+        """
+        Get a list of servers.
+
+        :rtype: list of :class:`Server`
+        """
+        return self._list("/servers")
+
+    def power_on(self, server, using_pxe=False, **kwargs):
+        """
+        Power on a server.
+
+        :param server: The :class:`Server` (or its ID) to power on.
+        :param using_pxe: power on server and use pxe boot.
+        """
+        action_params = {}
+        if using_pxe:
+            action_params = {"using-pxe": str(using_pxe)}
+        self._action('power-on', server, action_params)
+
+    def power_off(self, server, force=False, **kwargs):
+        """
+        Power off a server.
+
+        :param server: The :class:`Server` (or its ID) to power off.
+        :param force: force the server to power off.
+        """
+        action_params = {}
+        if force:
+            action_params = {"force": str(force)}
+        self._action('power-off', server, action_params)
+
+    def reset(self, server, using_pxe=False, **kwargs):
+        """
+        Reset power of a server.
+
+        :param server: The :class:`Server` (or its ID) to power on.
+        :param using_pxe: reset and power on server and use pxe boot.
+        """
+        action_params = {}
+        if using_pxe:
+            action_params = {"using-pxe": str(using_pxe)}
+        self._action('reset', server, action_params)
+
+    def set_tagged_vlan(self, server, vlan_id, **kwargs):
+        """
+        Set the tagged vlan id for the server.
+
+        :param server: The :class:`Server` (or its ID) to power on.
+        :param vlan_id: The tagged vlan id for the server.
+        """
+        self._handle_vlan(server, vlan_id, "tagged-vlan", **kwargs)
+
+    def unset_tagged_vlan(self, server, vlan_id, **kwargs):
+        """
+        Unset the tagged vlan id for the server.
+
+        :param server: The :class:`Server` (or its ID) to power on.
+        :param vlan_id: The tagged vlan id for the server.
+        """
+        self._handle_vlan(server, vlan_id, "tagged-vlan", unset=True, **kwargs)
+
+    def set_untagged_vlan(self, server, vlan_id, **kwargs):
+        """
+        Set the untagged vlan id for the server.
+
+        :param server: The :class:`Server` (or its ID) to power on.
+        :param vlan_id: The untagged vlan id for the server.
+        """
+        self._handle_vlan(server, vlan_id, "untagged-vlan", **kwargs)
+
+    def unset_untagged_vlan(self, server, vlan_id, **kwargs):
+        """
+        Unset the untagged vlan id for the server.
+
+        :param server: The :class:`Server` (or its ID) to power on.
+        :param vlan_id: The untagged vlan id for the server.
+        """
+        self._handle_vlan(server, vlan_id, "untagged-vlan",
+                          unset=True, **kwargs)
+
+    def _handle_vlan(self, server, vlan_id, vlan_type, unset=False, **kwargs):
+        """
+        Set/Unset tagged/untagged vlan id for the server.
+
+        :param server: The :class:`Server` (or its ID) to power on.
+        :param vlan_id: The tagged vlan id for the server.
+        :param vlan_type: tagged-vlan or untagged-vlan type.
+        :param unset: Boolean flag to unset the vlan_id for the server.
+        """
+        if vlan_id is not None:
+
+            action_params = {}
+            if unset:
+                action_params.update({'allow': 'False'})
+            action_params = {vlan_type: str(vlan_id)}
+            self._action('set-%s' % vlan_type, server, action_params)
+
+    def _action(self, action, server, info=None, **kwargs):
+        """
+        Perform a server "action" -- power-on/power-off/reset/etc.
+        """
+        body = {"action": action}
+        body.update(info)
+        self.run_hooks('modify_body_for_action', body, **kwargs)
+        url = '/servers/%s' % base.getid(server)
+        return self.api.client.put(url, body=body)

seamicroclient/v2/volumes.py

@@ -0,0 +1,87 @@
+#    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.
+
+"""
+Volume interface.
+"""
+
+
+from seamicroclient import base
+
+
+class Volume(base.Resource):
+    HUMAN_ID = True
+
+    def __repr__(self):
+        return "<Volume: %s>" % self.id
+
+    def delete(self):
+        self.manager.delete(self)
+
+
+class VolumeManager(base.ManagerWithFind):
+    resource_class = Volume
+
+    def get(self, volume):
+        """
+        Get a volume.
+
+        :param volume: ID of the :class:`Volume` to get.
+        :rtype: :class:`Volume`
+        """
+        return self._get(base.getid(volume),
+                         "/storage/volumes/%s" % base.getid(volume))
+
+    def list(self):
+        """
+        Get a list of volumes.
+
+        :rtype: list of :class:`Volume`
+        """
+        return self._list("/storage/volumes")
+
+    def create(self, volume_id, pool, size, **kwargs):
+        """
+        Create a volume of the given size in the given pool.
+
+        :param volume_id: ID of the :class: `Volume` to create
+        :param pool: Object  of the :class: `Pool` in which the volume will be
+                     created.
+        :param size: Size of the new volume in GB.
+        """
+        create_params = {}
+        if pool and volume_id and size:
+            create_params = {'volume-size': str(size)}
+            resource_url = "%s/%s" % (base.getid(pool), volume_id)
+            return self._create(resource_url, create_params)
+
+    def delete(self, volume):
+        self._delete("/storage/volume/%s" % base.getid(volume))
+
+    def _create(self, resource_url, body, **kwargs):
+        """
+        Create a volume
+        """
+        body.update({"action": "create"})
+        self.run_hooks('modify_body_for_action', body, **kwargs)
+        url = '/storage/volumes/%s' % resource_url
+        return self._update(url, body=body)
+
+    def _action(self, action, volume, info=None, **kwargs):
+        """
+        Perform a volume "action" -- .
+        """
+        body = {"action": action}
+        body.update(info)
+        self.run_hooks('modify_body_for_action', body, **kwargs)
+        url = '/storage/volumes/%s' % base.getid(volume)
+        return self.api.client.put(url, body=body)

setup.cfg

@@ -0,0 +1,22 @@
+[metadata]
+name = python-seamicroclient
+summary = Client library for Seamicro chassis API
+description-file =
+    README.md
+license = AMD LICENCE INFO HERE
+author = AMD
+author-email = rohan.kanade@izeltech.com
+home-page = https://github.com/seamicro/seamicro_api
+classifier =
+    Development Status :: 5 - Production/Stable
+    Environment :: Console
+    Environment :: Seamicro
+    Intended Audience :: Developers
+    Intended Audience :: Information Technology
+    License :: AMD LICENSE INFO HERE
+    Operating System :: OS Independent
+    Programming Language :: Python
+
+[files]
+packages =
+    seamicroclient

setup.py

@@ -1,22 +1,9 @@
-from setuptools import setup
-import sys
+#!/usr/bin/env python
+# AMD LICENSE HERE
 
-packages = ['seamicro_api', ]
-install_requires = ['enum', 'requests']
-tests_require = []
+# THIS FILE IS MANAGED BY THE GLOBAL REQUIREMENTS REPO - DO NOT EDIT
+import setuptools
 
-if sys.version_info < (2, 7, 0):
-    install_requires.append('simplejson')
-
-from seamicro_api import __version__
-
-
-setup(name='seamicro_api',
-      version=__version__,
-      description='Python bindings for SeaMicro API v0.9',
-      url='https://github.com/seamicro/scripts/seamicro_api',
-      packages=packages,
-      author='Vince Gonzalez',
-      author_email='vince.gonzalez@amd.com',
-      license='MIT',
-      install_requires=install_requires)
+setuptools.setup(
+    setup_requires=['pbr'],
+    pbr=True)

test-requirements.txt

@@ -0,0 +1,10 @@
+hacking>=0.8.0,<0.9
+
+coverage>=3.6
+discover
+fixtures>=0.3.14
+keyring>=1.6.1,<2.0
+mock>=1.0
+sphinx>=1.1.2,<1.2
+testrepository>=0.0.17
+testtools>=0.9.32

tools/install_venv.py

@@ -0,0 +1,77 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# All Rights Reserved.
+#
+# Copyright 2010 OpenStack Foundation
+# Copyright 2013 IBM Corp.
+# Copyright (c) 2013 Hewlett-Packard Development Company, L.P.
+#
+# 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 ConfigParser
+import os
+import sys
+
+import install_venv_common as install_venv  # flake8: noqa
+
+
+def print_help(project, venv, root):
+    help = """
+    %(project)s development environment setup is complete.
+
+    %(project)s development uses virtualenv to track and manage Python
+    dependencies while in development and testing.
+
+    To activate the %(project)s virtualenv for the extent of your current
+    shell session you can run:
+
+    $ source %(venv)s/bin/activate
+
+    Or, if you prefer, you can run commands in the virtualenv on a case by
+    case basis by running:
+
+    $ %(root)s/tools/with_venv.sh <your command>
+    """
+    print help % dict(project=project, venv=venv, root=root)
+
+
+def main(argv):
+    root = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+
+    if os.environ.get('tools_path'):
+        root = os.environ['tools_path']
+    venv = os.path.join(root, '.venv')
+    if os.environ.get('venv'):
+        venv = os.environ['venv']
+
+    pip_requires = os.path.join(root, 'requirements.txt')
+    test_requires = os.path.join(root, 'test-requirements.txt')
+    py_version = "python%s.%s" % (sys.version_info[0], sys.version_info[1])
+    setup_cfg = ConfigParser.ConfigParser()
+    setup_cfg.read('setup.cfg')
+    project = setup_cfg.get('metadata', 'name')
+
+    install = install_venv.InstallVenv(
+        root, venv, pip_requires, test_requires, py_version, project)
+    options = install.parse_args(argv)
+    install.check_python_version()
+    install.check_dependencies()
+    install.create_virtualenv(no_site_packages=options.no_site_packages)
+    install.install_dependencies()
+    install.post_process()
+    print_help(project, venv, root)
+
+if __name__ == '__main__':
+    main(sys.argv)

tools/install_venv_common.py

@@ -0,0 +1,214 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2013 OpenStack Foundation
+# Copyright 2013 IBM Corp.
+#
+#    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.
+
+"""Provides methods needed by installation script for OpenStack development
+virtual environments.
+
+Since this script is used to bootstrap a virtualenv from the system's Python
+environment, it should be kept strictly compatible with Python 2.6.
+
+Synced in from openstack-common
+"""
+
+from __future__ import print_function
+
+import optparse
+import os
+import subprocess
+import sys
+
+
+class InstallVenv(object):
+
+    def __init__(self, root, venv, requirements,
+                 test_requirements, py_version,
+                 project):
+        self.root = root
+        self.venv = venv
+        self.requirements = requirements
+        self.test_requirements = test_requirements
+        self.py_version = py_version
+        self.project = project
+
+    def die(self, message, *args):
+        print(message % args, file=sys.stderr)
+        sys.exit(1)
+
+    def check_python_version(self):
+        if sys.version_info < (2, 6):
+            self.die("Need Python Version >= 2.6")
+
+    def run_command_with_code(self, cmd, redirect_output=True,
+                              check_exit_code=True):
+        """Runs a command in an out-of-process shell.
+
+        Returns the output of that command. Working directory is self.root.
+        """
+        if redirect_output:
+            stdout = subprocess.PIPE
+        else:
+            stdout = None
+
+        proc = subprocess.Popen(cmd, cwd=self.root, stdout=stdout)
+        output = proc.communicate()[0]
+        if check_exit_code and proc.returncode != 0:
+            self.die('Command "%s" failed.\n%s', ' '.join(cmd), output)
+        return (output, proc.returncode)
+
+    def run_command(self, cmd, redirect_output=True, check_exit_code=True):
+        return self.run_command_with_code(cmd, redirect_output,
+                                          check_exit_code)[0]
+
+    def get_distro(self):
+        if (os.path.exists('/etc/fedora-release') or
+                os.path.exists('/etc/redhat-release')):
+            return Fedora(
+                self.root, self.venv, self.requirements,
+                self.test_requirements, self.py_version, self.project)
+        else:
+            return Distro(
+                self.root, self.venv, self.requirements,
+                self.test_requirements, self.py_version, self.project)
+
+    def check_dependencies(self):
+        self.get_distro().install_virtualenv()
+
+    def create_virtualenv(self, no_site_packages=True):
+        """Creates the virtual environment and installs PIP.
+
+        Creates the virtual environment and installs PIP only into the
+        virtual environment.
+        """
+        if not os.path.isdir(self.venv):
+            print('Creating venv...', end=' ')
+            if no_site_packages:
+                self.run_command(['virtualenv', '-q', '--no-site-packages',
+                                 self.venv])
+            else:
+                self.run_command(['virtualenv', '-q', self.venv])
+            print('done.')
+        else:
+            print("venv already exists...")
+            pass
+
+    def pip_install(self, *args):
+        self.run_command(['tools/with_venv.sh',
+                         'pip', 'install', '--upgrade'] + list(args),
+                         redirect_output=False)
+
+    def install_dependencies(self):
+        print('Installing dependencies with pip (this can take a while)...')
+
+        # First things first, make sure our venv has the latest pip and
+        # setuptools and pbr
+        self.pip_install('pip>=1.4')
+        self.pip_install('setuptools')
+        self.pip_install('pbr')
+
+        self.pip_install('-r', self.requirements)
+        self.pip_install('-r', self.test_requirements)
+
+    def post_process(self):
+        self.get_distro().post_process()
+
+    def parse_args(self, argv):
+        """Parses command-line arguments."""
+        parser = optparse.OptionParser()
+        parser.add_option('-n', '--no-site-packages',
+                          action='store_true',
+                          help="Do not inherit packages from global Python "
+                               "install")
+        return parser.parse_args(argv[1:])[0]
+
+
+class Distro(InstallVenv):
+
+    def check_cmd(self, cmd):
+        return bool(self.run_command(['which', cmd],
+                    check_exit_code=False).strip())
+
+    def install_virtualenv(self):
+        if self.check_cmd('virtualenv'):
+            return
+
+        if self.check_cmd('easy_install'):
+            print('Installing virtualenv via easy_install...', end=' ')
+            if self.run_command(['easy_install', 'virtualenv']):
+                print('Succeeded')
+                return
+            else:
+                print('Failed')
+
+        self.die('ERROR: virtualenv not found.\n\n%s development'
+                 ' requires virtualenv, please install it using your'
+                 ' favorite package management tool' % self.project)
+
+    def post_process(self):
+        """Any distribution-specific post-processing gets done here.
+
+        In particular, this is useful for applying patches to code inside
+        the venv.
+        """
+        pass
+
+
+class Fedora(Distro):
+    """This covers all Fedora-based distributions.
+
+    Includes: Fedora, RHEL, CentOS, Scientific Linux
+    """
+
+    def check_pkg(self, pkg):
+        return self.run_command_with_code(['rpm', '-q', pkg],
+                                          check_exit_code=False)[1] == 0
+
+    def apply_patch(self, originalfile, patchfile):
+        self.run_command(['patch', '-N', originalfile, patchfile],
+                         check_exit_code=False)
+
+    def install_virtualenv(self):
+        if self.check_cmd('virtualenv'):
+            return
+
+        if not self.check_pkg('python-virtualenv'):
+            self.die("Please install 'python-virtualenv'.")
+
+        super(Fedora, self).install_virtualenv()
+
+    def post_process(self):
+        """Workaround for a bug in eventlet.
+
+        This currently affects RHEL6.1, but the fix can safely be
+        applied to all RHEL and Fedora distributions.
+
+        This can be removed when the fix is applied upstream.
+
+        Nova: https://bugs.launchpad.net/nova/+bug/884915
+        Upstream: https://bitbucket.org/eventlet/eventlet/issue/89
+        RHEL: https://bugzilla.redhat.com/958868
+        """
+
+        if os.path.exists('contrib/redhat-eventlet.patch'):
+            # Install "patch" program if it's not there
+            if not self.check_pkg('patch'):
+                self.die("Please install 'patch'.")
+
+            # Apply the eventlet patch
+            self.apply_patch(os.path.join(self.venv, 'lib', self.py_version,
+                                          'site-packages',
+                                          'eventlet/green/subprocess.py'),
+                             'contrib/redhat-eventlet.patch')

tools/with_venv.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+TOOLS=`dirname $0`
+VENV=$TOOLS/../.venv
+source $VENV/bin/activate && $@

tox.ini

@@ -0,0 +1,33 @@
+[tox]
+envlist = py26,py27,py33,pypy,pep8
+minversion = 1.6
+skipsdist = True
+
+[testenv]
+usedevelop = True
+install_command = pip install -U {opts} {packages}
+setenv = VIRTUAL_ENV={envdir}
+         LANG=en_US.UTF-8
+         LANGUAGE=en_US:en
+         LC_ALL=C
+
+deps = -r{toxinidir}/requirements.txt
+       -r{toxinidir}/test-requirements.txt
+commands = python setup.py testr --testr-args='{posargs}'
+
+[testenv:pep8]
+commands = flake8
+
+[testenv:venv]
+commands = {posargs}
+
+[testenv:cover]
+commands = python setup.py testr --coverage --testr-args='{posargs}'
+
+[tox:jenkins]
+downloadcache = ~/cache/pip
+
+[flake8]
+ignore = E12,F841,F811,F821,H302,H404
+show-source = True
+exclude=.venv,.git,.tox,dist,doc,*openstack/common*,*lib/python*,*egg,build