Added a few methods that the CLI was expecting to be there

Author: Clark Perkins

stackdio/client/__init__.py

@@ -49,14 +49,6 @@ def get_root(self):
     def get_version(self):
         return self._get(endpoint, jsonify=True)['version']
 
-    @endpoint("blueprints/{blueprint_id}/")
-    def delete_blueprint(self, blueprint_id):
-        result = self._delete(endpoint, jsonify=True)
-        if result is None:
-            raise BlueprintException("Blueprint %s not found" % blueprint_id)
-        else:
-            return result
-
     @use_admin_auth
     @endpoint("security_groups/")
     def create_security_group(self, name, description, cloud_provider, is_default=True):

stackdio/client/blueprint.py

@@ -13,43 +13,40 @@ def create_blueprint(self, blueprint, provider="ec2"):
 
         # check the provided blueprint to see if we need to look up any ids
         for host in blueprint["hosts"]:
-            if isinstance(host["size"], str):
+            if isinstance(host["size"], basestring):
                 host["size"] = self.get_instance_id(host["size"], provider)
 
-            if isinstance(host["zone"], str):
-                host["zone"] = self.get_zone(host["zone"], provider)
+            if isinstance(host["zone"], basestring):
+                host["zone"] = self.get_zone_id(host["zone"], provider)
 
-            if isinstance(host["cloud_profile"], str):
+            if isinstance(host["cloud_profile"], basestring):
                 host["cloud_profile"] = self.get_profile_id(host["cloud_profile"])
 
             for component in host["formula_components"]:
                 if isinstance(component["id"], (tuple, list)):
+                    formula_id = self.get_formula_id(component["id"][0])
+
                     component["id"] = self.get_component_id(
-                        self.get_formula(component["id"][0]),
+                        self.get_formula(formula_id),
                         component["id"][1])
 
         return self._post(endpoint, data=json.dumps(blueprint), jsonify=True)
 
-
-
     @endpoint("blueprints/")
     def list_blueprints(self):
         """Return info for a specific blueprint_id"""
         return self._get(endpoint, jsonify=True)['results']
 
-
     @endpoint("blueprints/{blueprint_id}/")
     def get_blueprint(self, blueprint_id):
         """Return info for a specific blueprint_id"""
         return self._get(endpoint, jsonify=True)
 
-
     @endpoint("blueprints/")
     def search_blueprints(self, **kwargs):
         """Return info for a specific blueprint_id"""
         return self._get(endpoint, params=kwargs, jsonify=True)['results']
 
-
     @deprecated
     @accepted_versions("<0.7")
     def get_blueprint_id(self, title):

stackdio/client/formula.py

@@ -5,7 +5,6 @@
 
 
 class FormulaMixin(HttpMixin):
-
     @endpoint("formulas/")
     def import_formula(self, formula_uri, public=True):
         """Import a formula"""
@@ -15,36 +14,40 @@ def import_formula(self, formula_uri, public=True):
         }
         return self._post(endpoint, data=json.dumps(data), jsonify=True)
 
-
     @endpoint("formulas/")
     def list_formulas(self):
         """Return all formulas"""
         return self._get(endpoint, jsonify=True)['results']
 
-
     @endpoint("formulas/{formula_id}/")
     def get_formula(self, formula_id):
         """Get a formula with matching id"""
         return self._get(endpoint, jsonify=True)
 
-
     @endpoint("formulas/")
     def search_formulas(self, **kwargs):
         """Get a formula with matching id"""
         return self._get(endpoint, params=kwargs, jsonify=True)['results']
 
-
     @endpoint("formulas/{formula_id}/")
     def delete_formula(self, formula_id):
         """Delete formula with matching id"""
-        return self._delete(endpoint, jsonify=True)
-
+        return self._delete(endpoint)
 
     @endpoint("formulas/{formula_id}/action/")
     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"""

stackdio/client/http.py

@@ -83,9 +83,10 @@ class HttpMixin(object):
     }
 
     def __init__(self, auth=None, verify=True):
-        self._http_options = {}
-        self._http_options['auth'] = auth
-        self._http_options['verify'] = verify
+        self._http_options = {
+            'auth': auth,
+            'verify': verify,
+        }
         self._http_log = logging.getLogger(__name__)
 
     def _request(self, verb, url, quiet=False,
@@ -120,26 +121,20 @@ def _request(self, verb, url, quiet=False,
         else:
             return result
 
-
     def _head(self, url, *args, **kwargs):
         return self._request("HEAD", url, *args, **kwargs)
 
-
     def _get(self, url, *args, **kwargs):
         return self._request("GET", url, *args, **kwargs)
 
-
     def _delete(self, url, *args, **kwargs):
         return self._request("DELETE", url, *args, **kwargs)
 
-
     def _post(self, url, data=None, *args, **kwargs):
         return self._request("POST", url, data=data, *args, **kwargs)
 
-
     def _put(self, url, data=None, *args, **kwargs):
         return self._request("PUT", url, data=data, *args, **kwargs)
 
-
     def _patch(self, url, data=None, *args, **kwargs):
         return self._request("PATCH", url, data=data, *args, **kwargs)

stackdio/client/profile.py

@@ -58,4 +58,4 @@ def get_profile_id(self, slug, title=False):
             if profile.get("slug" if not title else "title") == slug:
                 return profile.get("id")
 
-        return StackException("Provider %s not found" % slug)
+        return StackException("Profile %s not found" % slug)

stackdio/client/provider.py

@@ -59,7 +59,7 @@ def create_provider(self, **kwargs):
 
 
     @endpoint("providers/")
-    def list_providers(self, provider_id):
+    def list_providers(self):
         """List all providers"""
         return self._get(endpoint, jsonify=True)['results']
 

stackdio/client/region.py

@@ -56,9 +56,12 @@ def get_zone_id(self, title, type_name="ec2"):
         """Get a zone id for title"""
 
         result = self._get(endpoint, jsonify=True)
+
+        type_id = self.get_provider_type_id(type_name)
         for zone in result['results']:
-            if zone.get("title") == title and \
-               zone.get("provider_type") == type_name:
-                return zone.get("id")
+            if zone.get("title") == title:
+                region = self._get(zone.get("region"), jsonify=True)
+                if region.get("provider_type") == type_id:
+                    return zone.get("id")
 
         raise StackException("Zone %s not found for %s" % (title, type_name))

stackdio/client/stack.py

@@ -6,46 +6,46 @@
 
 
 class StackMixin(HttpMixin):
+    VALID_LOG_TYPES = {
+        "provisioning": ['log', 'err'],
+        "global-orchestration": ['log', 'err'],
+        "orchestration": ['log', 'err'],
+        "launch": ['log'],
+    }
 
     @endpoint("stacks/")
     def create_stack(self, stack_data):
         """Launch a stack as described by stack_data"""
         return self._post(endpoint, data=json.dumps(stack_data), jsonify=True)
 
-
     @endpoint("stacks/")
     def list_stacks(self):
         """Return a list of all stacks"""
         return self._get(endpoint, jsonify=True)['results']
 
-
     @endpoint("stacks/{stack_id}/")
     def get_stack(self, stack_id):
         """Get stack info"""
         return self._get(endpoint, jsonify=True)
 
-
     @endpoint("stacks/")
     def search_stacks(self, *kwargs):
         """Search for stacks that match the given criteria"""
         return self._get(endpoint, params=kwargs, jsonify=True)['results']
 
-
     @endpoint("stacks/{stack_id}/")
     def delete_stack(self, stack_id):
         """Destructively delete a stack forever."""
         return self._delete(endpoint, jsonify=True)
 
-
     @endpoint("stacks/{stack_id}/action/")
-    def get_valid_stack_actions(self):
+    def get_valid_stack_actions(self, stack_id):
         return self._get(endpoint, jsonify=True)['available_actions']
 
-
     @endpoint("stacks/{stack_id}/action/")
     def do_stack_action(self, stack_id, action):
         """Execute an action on a stack"""
-        valid_actions = self.get_valid_actions(stack_id)
+        valid_actions = self.get_valid_stack_actions(stack_id)
 
         if action not in valid_actions:
             raise StackException("Invalid action, must be one of %s" %
@@ -55,7 +55,6 @@ def do_stack_action(self, stack_id, action):
 
         return self._post(endpoint, data=json.dumps(data), jsonify=True)
 
-
     @endpoint("stacks/{stack_id}/history/")
     def get_stack_history(self, stack_id):
         """Get stack info"""
@@ -65,7 +64,6 @@ def get_stack_history(self, stack_id):
         else:
             return result
 
-
     @deprecated
     @accepted_versions("<0.7")
     def get_stack_id(self, title):
@@ -78,13 +76,11 @@ def get_stack_id(self, title):
 
         raise StackException("Stack %s not found" % title)
 
-
     @endpoint("stacks/{stack_id}/hosts/")
     def get_stack_hosts(self, stack_id):
         """Get a list of all stack hosts"""
         return self._get(endpoint, jsonify=True)['results']
 
-
     @endpoint("stacks/{stack_id}/hosts/")
     def describe_hosts(self, stack_id, key="fqdn", ec2=False):
         """Retrieve a list of info about a stack. Defaults to the id for each
@@ -102,10 +98,57 @@ def describe_hosts(self, stack_id, key="fqdn", ec2=False):
             else:
                 host_details = host.get(EC2).get(key)
 
-            if host_details:
+            if host_details is not None:
                 stack_details.append(host_details)
 
         if stack_details:
             return stack_details
 
         raise StackException("Key %s for stack %s not available" % (key, stack_id))
+
+    @endpoint("stacks/{stack_id}/logs/{log_type}.{level}.{date}")
+    def get_logs(self, stack_id, log_type, level='log', date='latest', tail=None):
+        """Get logs for a stack"""
+
+        if log_type and log_type not in self.VALID_LOG_TYPES:
+            raise StackException("Invalid log type, must be one of %s" %
+                                 ", ".join(self.VALID_LOG_TYPES.keys()))
+
+        if level not in self.VALID_LOG_TYPES[log_type]:
+            raise StackException("Invalid log level, must be one of %s" %
+                                 ", ".join(self.VALID_LOG_TYPES[log_type]))
+
+        return self._get(endpoint, params={'tail': tail}).text
+
+    @endpoint("stacks/{stack_id}/security_groups/")
+    def list_access_rules(self, stack_id):
+        """Get Access rules for a stack"""
+
+        return self._get(endpoint, jsonify=True)['results']
+
+    @deprecated
+    @accepted_versions("<0.7")
+    def get_access_rule_id(self, stack_id, title):
+        """Find an access rule id"""
+
+        rules = self.list_access_rules(stack_id)
+
+        try:
+            for group in rules:
+                if group.get("blueprint_host_definition").get("title") == title:
+                    return group.get("id")
+        except TypeError, e:
+            pass
+
+        raise StackException("Access Rule %s not found" % title)
+
+    @endpoint("security_groups/{group_id}/rules/")
+    def list_rules_for_group(self, group_id):
+        return self._get(endpoint, jsonify=True)
+
+    @endpoint("security_groups/{group_id}/rules/")
+    def edit_access_rule(self, group_id, data=None):
+        """Add an access rule to a group"""
+
+        return self._put(endpoint, jsonify=True, data=json.dumps(data))
+