Merge pull request #19 from clarkperkins/feature/upgrade-to-0.7

Feature/upgrade to 0.7

Author: clarkperkins

requirements.txt

@@ -15,52 +15,43 @@
 # limitations under the License.
 #
 
-import os
 import sys
 
 from setuptools import setup, find_packages
-from pip.req import parse_requirements
-from pip.download import PipSession
 
 
 def test_python_version():
-    if float("%d.%d" % sys.version_info[:2]) < 2.6:
-        print('Your Python version {0}.{1}.{2} is not supported.'.format(
-            *sys.version_info[:3]))
-        print('stackdio requires Python 2.6 or newer.')
+    major = sys.version_info[0]
+    minor = sys.version_info[1]
+    micro = sys.version_info[2]
+    if float('%d.%d' % (major, minor)) < 2.6:
+        err_msg = ('Your Python version {0}.{1}.{2} is not supported.\n'
+                   'stackdio-server requires Python 2.6 or newer.\n'.format(major, minor, micro))
+        sys.stderr.write(err_msg)
         sys.exit(1)
 
-
-def load_pip_requirements(fp):
-    reqs, deps = [], []
-    for r in parse_requirements(fp, session=PipSession()):
-        if r.url is not None:
-            deps.append(str(r.url))
-        reqs.append(str(r.req))
-    return reqs, deps
-
 # Set version
 __version__ = '0.0.0'  # Explicit default
-execfile("stackdio/client/version.py")
+execfile('stackdio/client/version.py')
 
 
 SHORT_DESCRIPTION = ('A cloud deployment, automation, and orchestration '
                      'platform for everyone.')
-LONG_DESCRIPTION = SHORT_DESCRIPTION
 
-# If we have a README.md file, use its contents as the long description
-if os.path.isfile('README.md'):
-    with open('README.md') as f:
-        LONG_DESCRIPTION = f.read()
+# Use the README.md as the long description
+with open('README.md') as f:
+    LONG_DESCRIPTION = f.read()
 
+requirements = [
+    'simplejson',
+    'requests>=2.4.0,<2.6.0',
+]
 
 if __name__ == "__main__":
-    # build our list of requirements and dependency links based on our
-    # requirements.txt file
-    reqs, deps = load_pip_requirements('requirements.txt')
+    test_python_version()
 
     # Call the setup method from setuptools that does all the heavy lifting
-    # of packaging stackdio
+    # of packaging stackdio-client
     setup(
         name='stackdio',
         version=__version__,
@@ -73,17 +64,18 @@ def load_pip_requirements(fp):
         include_package_data=True,
         packages=find_packages(),
         zip_safe=False,
-        install_requires=reqs,
-        dependency_links=deps,
+        install_requires=requirements,
+        dependency_links=[],
         classifiers=[
-            'Development Status :: 3 - Alpha',
+            'Development Status :: 4 - Beta',
             'Environment :: Web Environment',
             'Framework :: Django',
             'Intended Audience :: Developers',
             'Intended Audience :: Information Technology',
             'Intended Audience :: System Administrators',
             'License :: OSI Approved :: Apache Software License',
             'Programming Language :: Python',
+            'Programming Language :: Python :: 2',
             'Programming Language :: Python :: 2.6',
             'Programming Language :: Python :: 2.7',
             'Topic :: System :: Clustering',

setup.py

@@ -19,12 +19,12 @@
 import logging
 
 from .http import use_admin_auth, endpoint
-from .exceptions import BlueprintException, StackException
+from .exceptions import BlueprintException, StackException, IncompatibleVersionException
 
 from .blueprint import BlueprintMixin
 from .formula import FormulaMixin
-from .profile import ProfileMixin
-from .provider import ProviderMixin
+from .account import AccountMixin
+from .image import ImageMixin
 from .region import RegionMixin
 from .settings import SettingsMixin
 from .stack import StackMixin
@@ -34,8 +34,8 @@
 logger = logging.getLogger(__name__)
 
 
-class StackdIO(BlueprintMixin, FormulaMixin, ProfileMixin,
-               ProviderMixin, RegionMixin, StackMixin, SettingsMixin):
+class StackdIO(BlueprintMixin, FormulaMixin, AccountMixin,
+               ImageMixin, RegionMixin, StackMixin, SettingsMixin):
 
     def __init__(self, protocol="https", host="localhost", port=443,
                  base_url=None, auth=None, auth_admin=None,
@@ -57,6 +57,10 @@ def __init__(self, protocol="https", host="localhost", port=443,
 
         _, self.version = _parse_version_string(self.get_version())
 
+        if self.version[0] != 0 or self.version[1] != 7:
+            raise IncompatibleVersionException('Server version {0}.{1}.{2} not '
+                                               'supported.'.format(**self.version))
+
     @endpoint("")
     def get_root(self):
         """Get the api root"""
@@ -79,10 +83,10 @@ def create_security_group(self, name, description, cloud_provider, is_default=Tr
         }
         return self._post(endpoint, data=json.dumps(data), jsonify=True)
 
-    @endpoint("settings/")
+    @endpoint("user/")
     def get_public_key(self):
-        """Get the public key for the logged in uesr"""
-        return self._get(endpoint, jsonify=True)['public_key']
+        """Get the public key for the logged in user"""
+        return self._get(endpoint, jsonify=True)['settings']['public_key']
 
     @endpoint("settings/")
     def set_public_key(self, public_key):

stackdio/client/__init__.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2014,  Digital Reasoning
+#
+# 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
+
+from .http import HttpMixin, endpoint
+
+
+class AccountMixin(HttpMixin):
+
+    @endpoint("cloud/providers/")
+    def list_providers(self):
+        """List all providers"""
+        return self._get(endpoint, jsonify=True)['results']
+
+    @endpoint("cloud/providers/")
+    def search_providers(self, provider_id):
+        """List all providers"""
+        return self._get(endpoint, jsonify=True)['results']
+
+    @endpoint("cloud/accounts/")
+    def create_account(self, **kwargs):
+        """Create an account"""
+
+        form_data = {
+            "title": None,
+            "account_id": None,
+            "provider": None,
+            "access_key_id": None,
+            "secret_access_key": None,
+            "keypair": None,
+            "security_groups": None,
+            "route53_domain": None,
+            "default_availability_zone": None,
+            "private_key": None
+        }
+
+        for key in form_data.keys():
+            form_data[key] = kwargs.get(key)
+
+        return self._post(endpoint, data=json.dumps(form_data), jsonify=True)
+
+    @endpoint("accounts/")
+    def list_accounts(self):
+        """List all account"""
+        return self._get(endpoint, jsonify=True)['results']
+
+    @endpoint("accounts/{account_id}/")
+    def get_account(self, account_id, none_on_404=False):
+        """Return the account that matches the given id"""
+        return self._get(endpoint, jsonify=True, none_on_404=none_on_404)
+
+    @endpoint("accounts/")
+    def search_accounts(self, account_id):
+        """List all accounts"""
+        return self._get(endpoint, jsonify=True)['results']
+
+    @endpoint("accounts/{account_id}/")
+    def delete_account(self, account_id):
+        """List all accounts"""
+        return self._delete(endpoint, jsonify=True)['results']

stackdio/client/account.py

@@ -17,9 +17,7 @@
 
 import json
 
-from .exceptions import StackException
 from .http import HttpMixin, endpoint
-from .version import accepted_versions, deprecated
 
 
 class BlueprintMixin(HttpMixin):
@@ -28,25 +26,33 @@ class BlueprintMixin(HttpMixin):
     def create_blueprint(self, blueprint, provider="ec2"):
         """Create a blueprint"""
 
-        # check the provided blueprint to see if we need to look up any ids
-        for host in blueprint["hosts"]:
-            if isinstance(host["size"], basestring):
-                host["size"] = self.get_instance_id(host["size"], provider)
+        formula_map = {}
+
+        if 'formula_versions' in blueprint:
+            all_formulas = self.list_formulas()
 
-            # zone isn't required if you provide a subnet_id
-            if 'zone' in host and isinstance(host["zone"], basestring):
-                host["zone"] = self.get_zone_id(host["zone"], provider)
+            used_formulas = []
 
-            if isinstance(host["cloud_profile"], basestring):
-                host["cloud_profile"] = self.get_profile_id(host["cloud_profile"])  # noqa
+            for formula_version in blueprint['formula_versions']:
+                for formula in all_formulas:
+                    if formula['uri'] == formula_version['formula']:
+                        formula['version'] = formula_version['version']
+                        used_formulas.append(formula)
+                        break
 
-            for component in host["formula_components"]:
-                if not component.get("sls_path") and isinstance(component["id"], (tuple, list)):
-                    formula_id = self.get_formula_id(component["id"][0])
+            for formula in used_formulas:
+                components = self._get(
+                    '{0}?version={1}'.format(formula['components'], formula['version']),
+                    jsonify=True,
+                )['results']
+                for component in components:
+                    formula_map[component['sls_path']] = formula['uri']
 
-                    component["id"] = self.get_component_id(
-                        self.get_formula(formula_id),
-                        component["id"][1])
+        # check the provided blueprint to see if we need to look up any ids
+        for host in blueprint['host_definitions']:
+            for component in host['formula_components']:
+                if component['sls_path'] in formula_map:
+                    component['formula'] = formula_map[component['sls_path']]
 
         return self._post(endpoint, data=json.dumps(blueprint), jsonify=True, raise_for_status=False)
 
@@ -68,15 +74,3 @@ def search_blueprints(self, **kwargs):
     @endpoint("blueprints/{blueprint_id}")
     def delete_blueprint(self, blueprint_id):
         return self._delete(endpoint, jsonify=True)
-
-    @deprecated
-    @accepted_versions("<0.7")
-    def get_blueprint_id(self, title):
-        """Get the id for a blueprint that matches title"""
-
-        blueprints = self.search_blueprints(title=title)
-
-        if not len(blueprints):
-            raise StackException("Blueprint %s not found" % title)
-
-        return blueprints[0]['id']

stackdio/client/blueprint.py

@@ -15,6 +15,7 @@
 # limitations under the License.
 #
 
+
 class StackException(Exception):
     pass
 

stackdio/client/exceptions.py

@@ -17,7 +17,6 @@
 
 import json
 
-from .exceptions import StackException
 from .http import HttpMixin, endpoint
 
 
@@ -55,23 +54,3 @@ def delete_formula(self, formula_id):
     def update_formula(self, formula_id):
         """Delete formula with matching id"""
         return self._post(endpoint, json.dumps({"action": "update"}), jsonify=True)
-
-    def get_formula_id(self, title):
-        """Find a stack id"""
-
-        formulas = self.list_formulas()
-        for formula in formulas:
-            if formula.get("title") == title:
-                return formula.get("id")
-
-        raise StackException("Formula %s not found" % title)
-
-    def get_component_id(self, formula, component_title):
-        """Get the id for a component from formula_id that matches title"""
-
-        for component in formula.get("components"):
-            if component.get("title") == component_title:
-                return component.get("id")
-
-        raise StackException("Component %s not found for formula %s" %
-                             (component_title, formula.get("title")))

stackdio/client/formula.py

@@ -122,8 +122,6 @@ def __init__(self, auth=None, verify=True):
             from requests.packages.urllib3 import disable_warnings
             disable_warnings()
 
-
-
     def _request(self, verb, url, quiet=False,
                  none_on_404=False, jsonify=False, raise_for_status=True,
                  *args, **kwargs):