Use the ansible url helpers

Author: Rémi REY

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017 Rémi REY
+Copyright (c) 2017-2018 Rémi REY
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

library/grafana_annotations.py

@@ -1,17 +1,12 @@
-#!/usr/bin/env python
+#!/usr/bin/python
 # -*- coding: utf-8 -*-
 
-from base64 import b64encode
 import urllib
 import time
 import json
-try:
-    import httplib
-except ImportError:
-    # Python 3
-    import http.client as httplib
 
-API_URI = "/api/annotations"
+from ansible.module_utils.urls import fetch_url, basic_auth_header, url_argument_spec
+from ansible.module_utils.basic import *
 
 DOCUMENTATION = '''
 ---
@@ -88,23 +83,6 @@
 '''
 
 
-def build_search_uri(uri, annotation):
-    """Return the search uri based on the annotation"""
-    params = []
-    tags = annotation.get("tags", None)
-    if tags:
-        for tag in tags:
-            params.append("tags=%s" % urllib.quote_plus(tag))
-    if annotation.get('time', None):
-        params.append("from=%s" % annotation.get('time'))
-    if annotation.get('timeEnd', None):
-        params.append("to=%s" % annotation.get('timeEnd'))
-    else:
-        params.append("to=%s" % (int(time.time()) * 1000))
-
-    if params:
-        uri = "%s?%s" % (uri, '&'.join(params))
-    return uri
 
 
 def default_filter(annos, annotation):
@@ -139,102 +117,135 @@ def region_filter(annos, annotation):
 
 def filter_annotations(annos, annotation):
     """Filter the annotations that does not match `annotation`"""
-    if annotation.get("isRegion", False) is True:
+    annotation = annotation.as_dict()
+    if annotation.get("isRegion", False):
         return region_filter(annos, annotation)
     return default_filter(annos, annotation)
 
 
 class GrafanaManager(object):
     """Manage communication with grafana HTTP API"""
-    def __init__(self, addr, user=None, passwd=None, token=None, secure=False):
-        self.addr = addr
-        self.headers = {"Content-Type": "application-json",
-                        "Accept": "application/json"}
-        self.secure = secure
-        if user and passwd:
-            cred = "%s:%s" % (user, passwd)
-            authorization = "Basic %s" % b64encode(cred).decode('ascii')
-        if token:
+
+    def __init__(self, module, url, url_username, url_password, token):
+        self.module = module
+        self.url = url
+        self.headers = {"Content-Type": "application-json", "Accept": "application/json"}
+        if url_username and url_password:
+            authorization = basic_auth_header(url_username, url_password)
+        elif token:
             authorization = "Bearer %s" % token
         self.headers["Authorization"] = authorization
 
-    def query(self, method, uri, data=None):
-        http = httplib.HTTPConnection(self.addr)
-        if self.secure:
-            http = httplib.HTTPSConnection(self.addr)
-        http.request(method, uri, data, headers=self.headers)
-        response = http.getresponse()
-        return response.status, json.loads(response.read())
+
+    def build_search_uri(self, annotation):
+        """Return the search url based on the annotation"""
+        params = []
+        annotation = annotation.as_dict()
+        tags = annotation.get("tags", None)
+        if tags:
+            for tag in tags:
+                params.append("tags=%s" % urllib.quote_plus(tag))
+        if annotation.get('time', None):
+            params.append("from=%s" % annotation.get('time'))
+        if annotation.get('timeEnd', None):
+            params.append("to=%s" % annotation.get('timeEnd'))
+        else:
+            params.append("to=%s" % (int(time.time()) * 1000))
+
+        if params:
+            uri = "%s?%s" % (self.url, '&'.join(params))
+        return uri
+
 
     def get_annotation(self, annotation):
         """Search for the annotation in grafana"""
-        uri = build_search_uri(API_URI, annotation)
-        status, annos = self.query("GET", uri)
-        if status != 200:
-            raise Exception("Grafana answered with HTTP %d" % status)
+        url = self.build_search_uri(annotation)
+        resp, info = fetch_url(self.module, url, data=annotation.json, headers=self.headers, method="GET")
+
+        status_code = info["status"]
+        if status_code != 200:
+            raise Exception("Grafana answered with HTTP %d" % status_code)
+
+        annos = json.loads(resp.read())
         return filter_annotations(annos, annotation)
 
-    def create_annotation(self, annotation):
-        """Submit an annotation to grafana"""
-        status, data = self.query("POST", API_URI, json.dumps(annotation))
-        if status != 200:
-            raise Exception("Grafana answered with HTTP %d" % response.status)
-        return data
+
+    def send_annotation(self, annotation):
+        resp, info = fetch_url(self.module, self.url, data=annotation.json, headers=self.headers, method="POST")
+
+        status_code = info["status"]
+        if not 200 <= status_code <= 299:
+            raise Exception("Grafana answered with HTTP %d" % status_code)
+        return resp.read()
+
+
+# {{{ Annotation object
+
+class Annotation(object):
+
+    def __init__(self, text, tags, tstamp=None, end_tstamp=None):
+        self.text = text
+        self.tags = tags
+        self._set_time(tstamp)
+        self.isRegion = False
+        if end_tstamp:
+            self.timeEnd = int(end_tstamp) * 1000
+            self.isRegion = True
+
+    def _set_time(self, tstamp=None, end_tstamp=None):
+        if tstamp:
+            self.time = int(tstamp) * 1000
+        else:
+            self.time = int(time.time()) * 1000
+
+    def as_dict(self):
+        return self.__dict__
+
+    @property
+    def json(self):
+        return json.dumps(self.__dict__)
+
+# }}}
 
 
 def main():
+    base_arg_spec = url_argument_spec()
+    base_arg_spec.update(
+        token=dict(required=False, default=None, no_log=True),
+        tstamp=dict(required=False, default=None),
+        end_tstamp=dict(required=False, default=None, type='int'),
+        tags=dict(required=False, default=[], type='list'),
+        text=dict(required=True, type='str'),
+    )
     module = AnsibleModule(
-        argument_spec={
-            'addr': dict(required=True),
-            'user': dict(required=False, default=None),
-            'passwd': dict(required=False, default=None, no_log=True),
-            'token': dict(required=False, default=None, no_log=True),
-            'time': dict(required=False, default=None),
-            'timeEnd': dict(required=False, default=None, type=int),
-            'tags': dict(required=False, default=[], type=list),
-            'text': dict(required=True, type=str),
-            'secure': dict(required=False, default=False, type=bool),
-        },
-        supports_check_mode=False
+        argument_spec=base_arg_spec,
+        supports_check_mode=False,
+        mutually_exclusive=[['url_username', 'token']]
     )
 
-    addr = module.params['addr']
-    user = module.params['user']
-    passwd = module.params['passwd']
+    url = module.params['url']
+    url_username = module.params['url_username']
+    url_password = module.params['url_password']
     token = module.params['token']
-    _time = module.params['time']
-    time_end = module.params['timeEnd']
+    tstamp = module.params['tstamp']
+    end_tstamp = module.params['end_tstamp']
     tags = ["ansible"] + module.params['tags']
     text = module.params['text']
-    secure = module.params['secure']
-
-    if (not user and not passwd) and not token:
-        module.fail_json(msg="Authentication method must be provided (user/passwd or token)")
 
-    grafana = GrafanaManager(addr, user=user, passwd=passwd, token=token, secure=secure)
+    annotation = Annotation(text, tags, tstamp=tstamp, end_tstamp=end_tstamp)
 
-    if not _time:
-        _time = int(time.time()) * 1000
-    else:
-        _time = int(_time) * 1000
+    grafana = GrafanaManager(module, url, url_username, url_password, token)
 
-    annotation = {"time": _time, "tags": tags, "text": text}
-
-    if time_end:
-        annotation['timeEnd'] = time_end * 1000
-        annotation['isRegion'] = True
 
     changed = False
     try:
         annotations = grafana.get_annotation(annotation)
         if not annotations:
-            annotation = grafana.create_annotation(annotation)
+            annotation = grafana.send_annotation(annotation)
             annotations = [annotation]
             changed = True
     except Exception as err:
-        module.fail_json(msg=str(err), annotation=annotation)
+        module.fail_json(msg=str(err), annotation=annotation.json)
     module.exit_json(annotations=annotations, changed=changed)
 
-
-#<<INCLUDE_ANSIBLE_MODULE_COMMON>>
 main()

test.yml

@@ -1,79 +1,113 @@
 - hosts: localhost
   connection: local
+  gather_facts: no
+  vars:
+    grafana_login: admin
+    grafana_password: admin
+    grafana_url: http://127.0.0.1:3000/api/annotations
   tasks:
+
     - name: Create a global annotation without time information (login/passwd)
       grafana_annotations:
-        addr: "127.0.0.1:3000"
-        user: "admin"
-        passwd: "admin"
+        url: "{{ grafana_url }}"
+        url_username: "{{ grafana_login }}"
+        url_password: "{{ grafana_password }}"
         text: "This is an annotation with automatic time value"
       register: anno
+      tags:
+        - base
 
     - name: Create a global annotation without time information (token)
       grafana_annotations:
-        addr: "127.0.0.1:3000"
+        url: "{{ grafana_url }}"
         token: "{{ lookup('env','GRAFANA_API_TOKEN') }}"
         text: "This is an annotation with automatic time value"
       register: anno
+      tags:
+        - token
 
     - debug:
         var: anno
+      tags:
+        - token
 
-    - shell: date +%s
-      register: curdate
+    - set_fact:
+        curdate: "{{ '%s' | strftime() | int}}"
+      tags:
+        - base
 
     - name: Create a global annotation with time annotation
       grafana_annotations:
-        addr: "127.0.0.1:3000"
-        user: "admin"
-        passwd: "admin"
-        time: "{{ curdate.stdout }}"
-        text: "This is an annotation explicitly set at 1514822276"
+        url: "{{ grafana_url }}"
+        url_username: "{{ grafana_login }}"
+        url_password: "{{ grafana_password }}"
+        tstamp: "{{ curdate }}"
+        text: "This is an annotation explicitly set at {{ curdate }}"
+        tags:
+            - test-tag
       register: anno
+      tags:
+        - base
 
     - debug:
         var: anno
+      tags:
+        - base
 
     - name: test idempotence
       grafana_annotations:
-        addr: "127.0.0.1:3000"
-        user: "admin"
-        passwd: "admin"
-        time: "{{ curdate.stdout }}"
-        text: "This is an annotation explicitly set at 1514822276"
+        url: "{{ grafana_url }}"
+        url_username: "{{ grafana_login }}"
+        url_password: "{{ grafana_password }}"
+        tstamp: "{{ curdate }}"
+        text: "This is an annotation explicitly set at {{ curdate }}"
+        tags:
+            - test-tag
       register: anno
+      tags:
+        - base
 
     - assert:
         that: not anno.changed
+      tags:
+        - base
 
-    - shell: date +%s
-      register: curdate
+    - set_fact:
+        start_date: "{{ '%s' | strftime() | int - 3600 }}"
+        end_date: "{{ '%s' | strftime() | int}}"
+      tags:
+        - region
 
-    - shell: expr $(date +%s) - 3600
-      register: start_date
-    
     - name: Create a global region annotation
       grafana_annotations:
-        addr: "127.0.0.1:3000"
-        user: "admin"
-        passwd: "admin"
-        time: "{{ start_date.stdout }}"
-        timeEnd: "{{ curdate.stdout }}"
+        url: "{{ grafana_url }}"
+        url_username: "{{ grafana_login }}"
+        url_password: "{{ grafana_password }}"
+        tstamp: "{{ start_date }}"
+        end_tstamp: "{{ end_date }}"
         text: "This is a global region annotation"
       register: anno
+      tags:
+        - region
 
     - debug:
         var: anno
+      tags:
+        - region
 
     - name: Test idempotence on region annotation
       grafana_annotations:
-        addr: "127.0.0.1:3000"
-        user: "admin"
-        passwd: "admin"
-        time: "{{ start_date.stdout }}"
-        timeEnd: "{{ curdate.stdout }}"
+        url: "{{ grafana_url }}"
+        url_username: "{{ grafana_login }}"
+        url_password: "{{ grafana_password }}"
+        tstamp: "{{ start_date }}"
+        end_tstamp: "{{ end_date }}"
         text: "This is a global region annotation"
       register: anno
+      tags:
+        - region
 
     - assert:
         that: not anno.changed
+      tags:
+        - region