[dashboard list] Add new endpoints + dog cmd for dashboard lists

datadog/api/__init__.py

@@ -18,6 +18,7 @@
 
 # Resources
 from datadog.api.comments import Comment
+from datadog.api.dashboard_lists import DashboardList
 from datadog.api.downtimes import Downtime
 from datadog.api.timeboards import Timeboard
 from datadog.api.events import Event

datadog/api/dashboard_lists.py

@@ -0,0 +1,48 @@
+from datadog.api.resources import (
+    ActionAPIResource,
+    CreateableAPIResource,
+    DeletableAPIResource,
+    GetableAPIResource,
+    ListableAPIResource,
+    UpdatableAPIResource
+)
+
+class DashboardList(ActionAPIResource, CreateableAPIResource, DeletableAPIResource, GetableAPIResource,
+    ListableAPIResource, UpdatableAPIResource):
+    """
+    A wrapper around Dashboard List HTTP API.
+    """
+    _class_url = '/dashboard/lists/manual'
+
+    @classmethod
+    def get_dashboards(cls, id, **params):
+        """
+        Get dashboards for a dashboard list.
+
+        :returns: Dictionary representing the API's JSON response
+        """
+        return super(DashboardList, cls)._trigger_class_action('GET', 'dashboards', id, params)
+
+    @classmethod
+    def add_dashboards(cls, id, **body):
+        """
+        Add dashboards to a dashboard list.
+
+        :param dashboards: dashboards to add to the dashboard list
+        :type dashboards: list of dashboard dicts, e.g. [{"type": "custom_timeboard", "id": 1104}]
+
+        :returns: Dictionary representing the API's JSON response
+        """
+        return super(DashboardList, cls)._trigger_class_action('POST', 'dashboards', id, params=None, **body)
+
+    @classmethod
+    def delete_dashboards(cls, id, **body):
+        """
+        Delete dashboards from a dashboard list.
+
+        :param dashboards: dashboards to delete from the dashboard list
+        :type dashboards: list of dashboard dicts, e.g. [{"type": "custom_timeboard", "id": 1234}]
+
+        :returns: Dictionary representing the API's JSON response
+        """
+        return super(DashboardList, cls)._trigger_class_action('DELETE', 'dashboards', id, params=None, **body)

datadog/api/hosts.py

@@ -8,7 +8,7 @@ class Host(ActionAPIResource):
     _class_url = '/host'
 
     @classmethod
-    def mute(cls, host_name, **params):
+    def mute(cls, host_name, **body):
         """
         Mute a host.
 
@@ -28,7 +28,7 @@ def mute(cls, host_name, **params):
         :returns: Dictionary representing the API's JSON response
 
         """
-        return super(Host, cls)._trigger_class_action('POST', 'mute', host_name, **params)
+        return super(Host, cls)._trigger_class_action('POST', 'mute', host_name, **body)
 
     @classmethod
     def unmute(cls, host_name):

datadog/api/monitors.py

@@ -57,7 +57,7 @@ def get_all(cls, **params):
         return super(Monitor, cls).get_all(**params)
 
     @classmethod
-    def mute(cls, id, **params):
+    def mute(cls, id, **body):
         """
         Mute a monitor.
 
@@ -70,10 +70,10 @@ def mute(cls, id, **params):
 
         :returns: Dictionary representing the API's JSON response
         """
-        return super(Monitor, cls)._trigger_class_action('POST', 'mute', id, **params)
+        return super(Monitor, cls)._trigger_class_action('POST', 'mute', id, **body)
 
     @classmethod
-    def unmute(cls, id, **params):
+    def unmute(cls, id, **body):
         """
         Unmute a monitor.
 
@@ -85,7 +85,7 @@ def unmute(cls, id, **params):
 
         :returns: Dictionary representing the API's JSON response
         """
-        return super(Monitor, cls)._trigger_class_action('POST', 'unmute', id, **params)
+        return super(Monitor, cls)._trigger_class_action('POST', 'unmute', id, **body)
 
     @classmethod
     def mute_all(cls):

datadog/api/resources.py

@@ -169,7 +169,7 @@ class ActionAPIResource(object):
     Actionable API Resource
     """
     @classmethod
-    def _trigger_class_action(cls, method, name, id=None, **params):
+    def _trigger_class_action(cls, method, name, id=None, params=None, **body):
         """
         Trigger an action
 
@@ -185,15 +185,20 @@ def _trigger_class_action(cls, method, name, id=None, **params):
         :param params: action parameters
         :type params: dictionary
 
+        :param body: action body
+        :type body: dictionary
+
         :returns: Dictionary representing the API's JSON response
         """
+        if params is None:
+            params = {}
         if id is None:
-            return APIClient.submit(method, cls._class_url + "/" + name, params)
+            return APIClient.submit(method, cls._class_url + "/" + name, body, **params)
         else:
-            return APIClient.submit(method, cls._class_url + "/" + str(id) + "/" + name, params)
+            return APIClient.submit(method, cls._class_url + "/" + str(id) + "/" + name, body, **params)
 
     @classmethod
-    def _trigger_action(cls, method, name, id=None, **params):
+    def _trigger_action(cls, method, name, id=None, **body):
         """
         Trigger an action
 
@@ -206,12 +211,12 @@ def _trigger_action(cls, method, name, id=None, **params):
         :param id: trigger the action for the specified resource object
         :type id: id
 
-        :param params: action parameters
-        :type params: dictionary
+        :param body: action body
+        :type body: dictionary
 
         :returns: Dictionary representing the API's JSON response
         """
         if id is None:
-            return APIClient.submit(method, name, params)
+            return APIClient.submit(method, name, body)
         else:
-            return APIClient.submit(method, name + "/" + str(id), params)
+            return APIClient.submit(method, name + "/" + str(id), body)

datadog/api/service_checks.py

@@ -8,7 +8,7 @@ class ServiceCheck(ActionAPIResource):
     A wrapper around ServiceCheck HTTP API.
     """
     @classmethod
-    def check(cls, **params):
+    def check(cls, **body):
         """
         Post check statuses for use with monitors
 
@@ -34,9 +34,9 @@ def check(cls, **params):
         """
 
         # Validate checks, include only non-null values
-        for param, value in params.items():
-            if param == 'status' and params[param] not in CheckStatus.ALL:
+        for param, value in body.items():
+            if param == 'status' and body[param] not in CheckStatus.ALL:
                 raise ApiError('Invalid status, expected one of: %s'
                                % ', '.join(str(v) for v in CheckStatus.ALL))
 
-        return super(ServiceCheck, cls)._trigger_action('POST', 'check_run', **params)
+        return super(ServiceCheck, cls)._trigger_action('POST', 'check_run', **body)

datadog/dogshell/__init__.py

@@ -8,6 +8,7 @@
 from datadog import initialize
 from datadog.dogshell.comment import CommentClient
 from datadog.dogshell.common import DogshellConfig
+from datadog.dogshell.dashboard_list import DashboardListClient
 from datadog.dogshell.downtime import DowntimeClient
 from datadog.dogshell.event import EventClient
 from datadog.dogshell.host import HostClient
@@ -56,6 +57,7 @@ def main():
     MonitorClient.setup_parser(subparsers)
     TimeboardClient.setup_parser(subparsers)
     ScreenboardClient.setup_parser(subparsers)
+    DashboardListClient.setup_parser(subparsers)
     HostClient.setup_parser(subparsers)
     DowntimeClient.setup_parser(subparsers)
     ServiceCheckClient.setup_parser(subparsers)

datadog/dogshell/dashboard_list.py

@@ -0,0 +1,201 @@
+# 3p
+from datadog.util.format import pretty_json
+
+# datadog
+from datadog import api
+from datadog.dogshell.common import report_errors, report_warnings
+from datadog.util.compat import json
+
+class DashboardListClient(object):
+
+    @classmethod
+    def setup_parser(cls, subparsers):
+        parser = subparsers.add_parser('dashboard_list', help="Create, edit, and delete dashboard lists")
+        parser.add_argument('--string_ids', action='store_true', dest='string_ids',
+                            help="Represent dashboard list IDs as strings instead of ints in JSON")
+
+        verb_parsers = parser.add_subparsers(title='Verbs', dest='verb')
+        verb_parsers.required = True
+
+        # Create Dashboard List parser
+        post_parser = verb_parsers.add_parser('post', help="Create a dashboard list")
+        post_parser.add_argument('name', help="Name for the dashboard list")
+        post_parser.set_defaults(func=cls._post)
+
+        # Update Dashboard List parser
+        update_parser = verb_parsers.add_parser('update', help="Update existing dashboard list")
+        update_parser.add_argument('dashboard_list_id', help="Dashboard list to replace with the new definition")
+        update_parser.add_argument('name', help="Name for the dashboard list")
+        update_parser.set_defaults(func=cls._update)
+
+        # Show Dashboard List parser
+        show_parser = verb_parsers.add_parser('show', help="Show a dashboard list definition")
+        show_parser.add_argument('dashboard_list_id', help="Dashboard list to show")
+        show_parser.set_defaults(func=cls._show)
+
+        # Show All Dashboard Lists parser
+        show_all_parser = verb_parsers.add_parser('show_all', help="Show a list of all dashboard lists")
+        show_all_parser.set_defaults(func=cls._show_all)
+
+        # Delete Dashboard List parser
+        delete_parser = verb_parsers.add_parser('delete', help="Delete existing dashboard list")
+        delete_parser.add_argument('dashboard_list_id', help="Dashboard list to delete")
+        delete_parser.set_defaults(func=cls._delete)
+
+        # Get Dashboards for Dashboard List parser
+        get_dashboards_parser = verb_parsers.add_parser('show_dashboards',
+            help="Show a list of all dashboards for an existing dashboard list")
+        get_dashboards_parser.add_argument('dashboard_list_id', help="Dashboard list to show dashboards from")
+        get_dashboards_parser.set_defaults(func=cls._show_dashboards)
+
+        # Add Dashboards to Dashboard List parser
+        add_dashboards_parser = verb_parsers.add_parser('add_dashboards',
+            help="Add dashboards to an existing dashboard list")
+        add_dashboards_parser.add_argument('dashboard_list_id', help="Dashboard list to add dashboards to")
+        add_dashboards_parser.add_argument('dashboards',
+            help='A JSON list of dashboard dicts, e.g. ' +
+                 '[{"type": "custom_timeboard", "id": 1234}, {"type": "custom_screenboard", "id": 123}]')
+        add_dashboards_parser.set_defaults(func=cls._add_dashboards)
+
+        # Delete Dashboards from Dashboard List parser
+        delete_dashboards_parser = verb_parsers.add_parser('delete_dashboards',
+            help="Delete dashboards from an existing dashboard list")
+        delete_dashboards_parser.add_argument('dashboard_list_id', help="Dashboard list to delete dashboards from")
+        delete_dashboards_parser.add_argument('dashboards',
+            help='A JSON list of dashboard dicts, e.g. ' +
+                 '[{"type": "custom_timeboard", "id": 1234}, {"type": "custom_screenboard", "id": 123}]')
+        delete_dashboards_parser.set_defaults(func=cls._delete_dashboards)
+
+    @classmethod
+    def _post(cls, args):
+        api._timeout = args.timeout
+        format = args.format
+        name = args.name
+
+        res = api.DashboardList.create(name=name)
+        report_warnings(res)
+        report_errors(res)
+
+        if format == 'pretty':
+            print(pretty_json(res))
+        else:
+            print(json.dumps(res))
+
+    @classmethod
+    def _update(cls, args):
+        api._timeout = args.timeout
+        format = args.format
+        dashboard_list_id = args.dashboard_list_id
+        name = args.name
+
+        res = api.DashboardList.update(dashboard_list_id, name=name)
+        report_warnings(res)
+        report_errors(res)
+
+        if format == 'pretty':
+            print(pretty_json(res))
+        else:
+            print(json.dumps(res))
+
+    @classmethod
+    def _show(cls, args):
+        api._timeout = args.timeout
+        format = args.format
+        dashboard_list_id = args.dashboard_list_id
+
+        res = api.DashboardList.get(dashboard_list_id)
+        report_warnings(res)
+        report_errors(res)
+
+        if args.string_ids:
+            res['id'] = str(res['id'])
+
+        if format == 'pretty':
+            print(pretty_json(res))
+        else:
+            print(json.dumps(res))
+
+    @classmethod
+    def _show_all(cls, args):
+        api._timeout = args.timeout
+        format = args.format
+
+        res = api.DashboardList.get_all()
+        report_warnings(res)
+        report_errors(res)
+
+        if args.string_ids:
+            for dashboard_list in res['dashboard_lists']:
+                dashboard_list['id'] = str(dashboard_list['id'])
+
+        if format == 'pretty':
+            print(pretty_json(res))
+        else:
+            print(json.dumps(res))
+
+    @classmethod
+    def _delete(cls, args):
+        api._timeout = args.timeout
+        format = args.format
+        dashboard_list_id = args.dashboard_list_id
+
+        res = api.DashboardList.delete(dashboard_list_id)
+        report_warnings(res)
+        report_errors(res)
+
+        if format == 'pretty':
+            print(pretty_json(res))
+        else:
+            print(json.dumps(res))
+
+    @classmethod
+    def _show_dashboards(cls, args):
+        api._timeout = args.timeout
+        format = args.format
+        dashboard_list_id = args.dashboard_list_id
+
+        res = api.DashboardList.get_dashboards(dashboard_list_id)
+        report_warnings(res)
+        report_errors(res)
+
+        if args.string_ids:
+            for dashboard in res['dashboards']:
+                dashboard['id'] = str(dashboard['id'])
+
+        if format == 'pretty':
+            print(pretty_json(res))
+        else:
+            print(json.dumps(res))
+
+    @classmethod
+    def _add_dashboards(cls, args):
+        api._timeout = args.timeout
+        format = args.format
+        dashboard_list_id = args.dashboard_list_id
+        dashboards = json.loads(args.dashboards)
+
+        res = api.DashboardList.add_dashboards(dashboard_list_id, dashboards=dashboards)
+        report_warnings(res)
+        report_errors(res)
+
+        if format == 'pretty':
+            print(pretty_json(res))
+        else:
+            print(json.dumps(res))
+
+    @classmethod
+    def _delete_dashboards(cls, args):
+        api._timeout = args.timeout
+        format = args.format
+        dashboard_list_id = args.dashboard_list_id
+        dashboards = json.loads(args.dashboards)
+
+        res = api.DashboardList.delete_dashboards(dashboard_list_id, dashboards=dashboards)
+        report_warnings(res)
+        report_errors(res)
+
+        if format == 'pretty':
+            print(pretty_json(res))
+        else:
+            print(json.dumps(res))
+