Start using config in the client

Author: Clark Perkins

setup.py

@@ -48,7 +48,7 @@ def test_python_version():
 
 requirements = [
     'Jinja2==2.7.3',
-    'PyYAML==3.11',
+    'PyYAML>=3.10',
     'click>=6.0,<7.0',
     'click-shell==0.1',
     'keyring==3.7',

stackdio/cli/__init__.py

@@ -13,9 +13,8 @@
 from requests import ConnectionError
 
 from stackdio.cli import mixins
-from stackdio.client import StackdIO
+from stackdio.client import StackdioClient
 from stackdio.client.config import StackdioConfig
-from stackdio.client.exceptions import MissingConfigException
 from stackdio.client.version import __version__
 
 
@@ -39,7 +38,7 @@ def load_config(fail_on_misconfigure, section='stackdio'):
 
 
 def get_client(config):
-    return StackdIO(
+    return StackdioClient(
         base_url=config['url'],
         auth=(
             config['username'],
@@ -66,29 +65,6 @@ def stackdio(ctx):
     ctx.obj = StackdioObj(ctx, ctx.invoked_subcommand != 'configure')
 
 
-@stackdio.group()
-def stacks():
-    pass
-
-
-@stackdio.group()
-def blueprints():
-    pass
-
-
-@blueprints.command()
-@click.option('--template', '-t')
-@click.option('--var-file', '-v', multiple=True)
-def create(template, var_file):
-    click.echo(template)
-    click.echo(var_file)
-
-
-@stackdio.group()
-def formulas():
-    pass
-
-
 @stackdio.command()
 def configure():
     config = StackdioConfig(create=True)
@@ -150,8 +126,8 @@ def get_names(self):
             return ["do_initial_setup", "do_help"]
 
     def _init_stacks(self):
-        """Instantiate a StackdIO object"""
-        self.stacks = StackdIO(
+        """Instantiate a StackdioClient object"""
+        self.stacks = StackdioClient(
             base_url=self.config["url"],
             auth=(
                 self.config["username"],
@@ -275,7 +251,7 @@ def do_account_summary(self, args=None):
 
 
 def main():
-    stackdio()
+    stackdio(obj={})
 
     # parser = argparse.ArgumentParser(
     #     description="Invoke the stackdio cli")

stackdio/cli/mixins/__init__.py

@@ -1,4 +0,0 @@
-import stackdio.cli.mixins.blueprints
-import stackdio.cli.mixins.bootstrap
-import stackdio.cli.mixins.formulas
-import stackdio.cli.mixins.stacks

stackdio/cli/mixins/blueprints.py

@@ -170,7 +170,7 @@ def _create_blueprint(self, args, bootstrap=False):
         if not bootstrap:
             print("Creating blueprint")
 
-        r = self.stacks.create_blueprint(bp_json)
+        r = self.stacks.create_blueprint(bp_json, raise_for_status=False)
         print(json.dumps(r, indent=2))
 
     def _create_single(self, template_file, var_files, no_prompt):

stackdio/client/__init__.py

@@ -19,41 +19,52 @@
 
 from .account import AccountMixin
 from .blueprint import BlueprintMixin
-from .exceptions import BlueprintException, StackException, IncompatibleVersionException
+from .config import StackdioConfig
+from .exceptions import (
+    BlueprintException,
+    StackException,
+    IncompatibleVersionException,
+    MissingUrlException
+)
 from .formula import FormulaMixin
-from .http import get, post, patch
+from .http import HttpMixin, get, post, patch
 from .image import ImageMixin
 from .region import RegionMixin
 from .settings import SettingsMixin
 from .stack import StackMixin
 from .version import _parse_version_string
 
 logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
 
 
-class StackdIO(BlueprintMixin, FormulaMixin, AccountMixin,
-               ImageMixin, RegionMixin, StackMixin, SettingsMixin):
+class StackdioClient(BlueprintMixin, FormulaMixin, AccountMixin, ImageMixin,
+                     RegionMixin, StackMixin, SettingsMixin, HttpMixin):
 
-    def __init__(self, protocol="https", host="localhost", port=443,
-                 base_url=None, auth=None, verify=True):
+    def __init__(self, url=None, username=None, password=None, verify=True):
+        self.config = StackdioConfig()
 
-        super(StackdIO, self).__init__(auth=auth, verify=verify)
-        if base_url:
-            self.url = base_url if base_url.endswith('/') else "%s/" % base_url
-        else:
-            self.url = "{protocol}://{host}:{port}/api/".format(
-                protocol=protocol,
-                host=host,
-                port=port)
+        if self.config.usable_config:
+            # Grab stuff from the config
+            url = self.config['url']
+            username = self.config['username']
+            verify = self.config['verify']
 
-        self.auth = auth
+        super(StackdioClient, self).__init__(url=url, auth=(username, password), verify=verify)
+        self.url = url
 
-        _, self.version = _parse_version_string(self.get_version())
+        try:
+            _, self.version = _parse_version_string(self.get_version())
+        except MissingUrlException:
+            self.version = None
 
-        if self.version[0] != 0 or self.version[1] != 7:
+        if self.version and self.version[0] != 0 or self.version[1] != 7:
             raise IncompatibleVersionException('Server version {0}.{1}.{2} not '
                                                'supported.'.format(**self.version))
 
+    def usable(self):
+        return self.config.usable_config
+
     @get('')
     def get_root(self):
         pass
@@ -67,12 +78,12 @@ def get_version(self, resp):
         return resp['version']
 
     @post('cloud/security_groups/')
-    def create_security_group(self, name, description, cloud_provider, is_default=True):
-        """Create a security group"""
+    def create_security_group(self, name, description, cloud_account, group_id, is_default=True):
 
         return {
-            "name": name,
-            "description": description,
-            "cloud_provider": cloud_provider,
-            "is_default": is_default
+            'name': name,
+            'description': description,
+            'cloud_account': cloud_account,
+            'group_id': group_id,
+            'is_default': is_default
         }

stackdio/client/config.py

@@ -22,33 +22,34 @@
 from requests.exceptions import ConnectionError, MissingSchema
 
 from stackdio.client.compat import ConfigParser, NoOptionError
-from stackdio.client.exceptions import MissingConfigException
 
 
 CFG_DIR = os.path.join(os.path.expanduser('~'), '.stackdio')
 CFG_FILE = os.path.join(CFG_DIR, 'client.cfg')
 
 
 class StackdioConfig(object):
+    """
+    A wrapper around python's ConfigParser class
+    """
 
     BOOL_MAP = {
         str(True): True,
         str(False): False,
     }
 
-    def __init__(self, section='stackdio', config_file=CFG_FILE, create=False):
+    def __init__(self, config_file=CFG_FILE, section='default'):
         super(StackdioConfig, self).__init__()
 
         self.section = section
 
         self._cfg_file = config_file
 
-        if not create and not os.path.isfile(config_file):
-            raise MissingConfigException('{0} does not exist'.format(config_file))
+        self.usable_config = os.path.isfile(config_file)
 
         self._config = ConfigParser()
 
-        if create:
+        if not self.usable_config:
             self._config.add_section(section)
         else:
             self._config.read(config_file)

stackdio/client/exceptions.py

@@ -16,7 +16,7 @@
 #
 
 
-class MissingConfigException(Exception):
+class MissingUrlException(Exception):
     pass
 
 

stackdio/client/http.py

@@ -23,10 +23,12 @@
 
 from inspect import getcallargs
 
+from .exceptions import MissingUrlException
+
 logger = logging.getLogger(__name__)
 logger.addHandler(logging.NullHandler())
 
-HTTP_INSECURE_MESSAGE = "\n".join([
+HTTP_INSECURE_MESSAGE = '\n'.join([
     "You have chosen not to verify ssl connections.",
     "This is insecure, but it's your choice.",
     "This has been your single warning."
@@ -37,14 +39,15 @@ class HttpMixin(object):
     """Add HTTP request features to an object"""
 
     HEADERS = {
-        'json': {"content-type": "application/json"},
-        'xml': {"content-type": "application/xml"}
+        'json': {'content-type': 'application/json'},
+        'xml': {'content-type': 'application/xml'},
     }
 
-    def __init__(self, auth=None, verify=True):
+    def __init__(self, url, auth=None, verify=True):
         super(HttpMixin, self).__init__()
 
-        self._http_options = {
+        self.url = url
+        self.http_options = {
             'auth': auth,
             'verify': verify,
         }
@@ -59,6 +62,9 @@ def __init__(self, auth=None, verify=True):
             from requests.packages.urllib3 import disable_warnings
             disable_warnings()
 
+    def usable(self):
+        raise NotImplementedError()
+
 
 def default_response(obj, response):
     return response
@@ -102,12 +108,20 @@ def __repr__(self):
         # We need this so we can save the client object as an attribute, and then it can be used
         # in __call__
         def __get__(self, obj, objtype=None):
+            if objtype:
+                assert issubclass(objtype, HttpMixin)
+            assert isinstance(obj, HttpMixin)
+
             self.obj = obj
-            assert issubclass(objtype, HttpMixin)
             return self
 
         # Here's how the request actually happens
         def __call__(self, *args, **kwargs):
+            assert isinstance(self.obj, HttpMixin)
+
+            if not self.obj.usable():
+                raise MissingUrlException('No url is set')
+
             none_on_404 = kwargs.pop('none_on_404', False)
             raise_for_status = kwargs.pop('raise_for_status', True)
 
@@ -131,10 +145,10 @@ def __call__(self, *args, **kwargs):
             result = requests.request(method,
                                       url,
                                       data=data,
-                                      auth=self.obj._http_options['auth'],
+                                      auth=self.obj.http_options['auth'],
                                       headers=self.headers,
                                       params=kwargs,
-                                      verify=self.obj._http_options['verify'])
+                                      verify=self.obj.http_options['verify'])
 
             # Handle special conditions
             if none_on_404 and result.status_code == 404:
@@ -164,10 +178,10 @@ def __call__(self, *args, **kwargs):
                     next_page = requests.request(method,
                                                  next_url,
                                                  data=data,
-                                                 auth=self.obj._http_options['auth'],
+                                                 auth=self.obj.http_options['auth'],
                                                  headers=self.headers,
                                                  params=kwargs,
-                                                 verify=self.obj._http_options['verify']).json()
+                                                 verify=self.obj.http_options['verify']).json()
                     res.extend(next_page['results'])
                     next_url = next_page.get('next')