Merge pull request #14 from ARGOeu/devel

Preparing for production

Author: kkoumantaros

.gitignore

@@ -0,0 +1,8 @@
+*.pyc
+*.pyo
+*.egg-info
+*.egg
+*.EGG
+*.EGG-INFO
+buld
+dist

.travis.yml

@@ -0,0 +1,6 @@
+language: python
+# Target py version 2.7
+python:
+  - "2.7"
+
+script: pytest

MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md
+include requirements.txt

README.md

@@ -1 +1,125 @@
-# argo-alert
+argo-alert
+===============================
+
+version number: 0.0.1
+author: GRNET
+
+Overview
+--------
+
+Streaming Publisher of argo-streaming status events as alerts to an alerta service endpoint.
+Alerta mail configuration rules from gocdb contact data.
+
+Argo streaming-service produces status events with the following schema:
+```
+json
+{
+  "endpoint_group":"SITE-A"
+  "service":"SERVICE-A",
+  "hostname":"host-A.site-A.foo"
+  "metric":"metric-A"
+  "status":"warning"
+  "summary":"a warning message"
+  "type":"metric"
+}
+```
+
+There are four types of status events: `[ "endpoint_group", "service", "endpoint", "metric"]`
+
+Argo-alert connects to a kafka-topic and receives such status events. Each event is
+then transformed to a compatible alerta schema and gets published to an alerta service endpoint.
+
+Alerta-mailer rule generation
+---------------------------
+Argo-alert provides the ability to create alerta-mailer rules from gocdb contact data. Argo-alert
+connects to a defined gocdb api endpoint and transforms the xml contact information to alerta-mailer
+rule json format. The rules are saved to a defined output file. The parameter `use_notifications_flag`
+(by default set to `True`) is used to select only the gocdb contacts that contain
+`<NOTIFICATIONS>Y</NOTIFICATIONS>` xml element. If the gocdb instance doesn't support notifications flag
+please set `use_notifications_flag=False`. 
+
+The configuration file for argo-alert provides a `[gocdb]` section to configure the gocdb endpoint
+and the required certificate parameters for access. The `mail-rules` parameter in `[alerta]` section
+specifies the alerta-mailer rule filename for output.  
+
+
+Installation / Usage
+--------------------
+
+To install use pip:
+
+    $ pip install argoalert
+
+
+Or clone the repo:
+
+    $ git clone https://github.com/ARGOeu/argoalert.git
+    $ python setup.py install
+
+
+argoalert requires a configuration file with the following options:
+```
+[gocdb]
+# Path to godcb endpoint
+api=https://gocdb-url.example.foo
+# Path to ca bundle folder
+cabundle=/path/to/cabundle
+# Path to host certificate file
+hostcert=/path/to/hostcert
+# Path to host key file
+hostkey=/path/to/hostkey
+# Verify https requests
+verify=False
+# Examine notification flag when selecting contacts
+use_notifications_flag=True
+# request path for gocdb to retrieve top-level items
+top_request=/gocdbpi/public/?method=get_site
+# request path for gocdb to retrieve sub-level items
+sub_request=/gocdbpi/public/?method=get_service
+
+[kafka]
+# kafka endpoint
+endpoint=localhost:9092
+# kafka topic
+topic=metrics
+
+[alerta]
+# alerta service endpoint
+endpoint=http://localhost:8080
+# alerta enviroment
+environment=devel
+# alerta token
+token=s3cr3tt0ke3n
+# path to store the generated mail rules
+mail-rules=/home/root/alerta-rules-101
+
+[logging]
+# loggin level
+level = INFO
+
+```
+
+To run argo-alert publisher:
+
+    $ argo-alert-publisher -c /path/to/argo-alert.conf
+
+To run argo-alert mail rule generator:
+
+    $ argo-alert-rulegen -c /path/to/argo-alert.conf
+    
+Using test-emails
+-----------------
+For testing purposes if you want to distribute notifications using a list
+of your own email aliases (before using client contact emails) issue:
+
+    $ argo-alert-rulegen -c /path/to/argo-alert.conf --test-emails test01@email.foo,test02@email.foo,test03@email.foo
+
+The rule list will be generated using the configured client sources but each client
+email will be replaced (using round-robin method) by a test-email (as defined in the cli arg list)
+
+Run tests
+---------
+
+To run argo-alert tests:
+
+    $ pytest

argoalert/__init__.py

@@ -0,0 +1,222 @@
+from kafka import KafkaConsumer
+import json
+import requests
+import logging
+from defusedxml.minidom import parseString
+
+
+def transform(argo_event, environment):
+    """Transform an argo status event to an alerta alert
+
+    Args:
+        argo_event: obj. Json representation of an argo status event
+        environment: str. Alerta enviroment parameter to build the alert
+
+    Return:
+        obj: Json representation of an alerta alert
+    """
+    status = argo_event["status"].lower()
+    hostname = argo_event["hostname"]
+    metric = argo_event["metric"]
+    group = argo_event["endpoint_group"]
+    etype = argo_event["type"]
+    service = argo_event["service"]
+
+    # alerta vars
+    resource = ""
+    event = "status"
+    alerta_service = []
+
+    if etype == "endpoint_group":
+        alerta_service.append("endpoint_group")
+        resource = group
+    elif etype == "service":
+        alerta_service.append("service")
+        resource = group + "/" + service
+    elif etype == "endpoint":
+        alerta_service.append("endpoint")
+        resource = group + "/" + service + "/" + hostname
+    elif etype == "metric":
+        alerta_service.append("metric")
+        resource = group + "/" + service + "/" + hostname + "/" + metric
+    # prepare alerta json
+    alerta = {"environment": environment, "event": event, "resource": resource,
+              "service": alerta_service, "severity": status}
+
+    return alerta
+
+
+def read_and_send(message, environment, alerta_url, alerta_token):
+    """Read an argo status event from kafka and send it to alerta
+
+    Args:
+        message: str. Current message from kafka queue
+        environment: str. Alerta environment to be used (e.g. 'Devel')
+        alerta_url: str. Alerta api endpoint
+        alerta_token: str. Alerta api access token
+
+    """
+    try:
+        argo_event = json.loads(message.value)
+    except ValueError:
+        logging.warning("NOT JSON: " + message.value)
+        return
+
+    try:
+        alerta = transform(argo_event, environment)
+    except KeyError:
+        logging.warning("WRONG JSON SCHEMA: " + message.value)
+        return
+
+    logging.info("Attempting to send alert:" + json.dumps(alerta))
+    headers = {'Authorization': 'Key ' + alerta_token,
+               'Content-Type': 'application/json'}
+
+    r = requests.post(alerta_url + "/alert", headers=headers,
+                      data=json.dumps(alerta))
+    
+    if r.status_code == 201:
+        logging.info("Alert send to alerta successfully")
+    else:
+        logging.warning("Alert wasn't send to alerta")
+        logging.warning(r.text)
+
+
+def start_listening(environment, kafka_endpoints, kafka_topic,
+                    alerta_endpoint, alerta_token):
+    """Start listening to a kafka topic and send alerts to an alerta endpoint
+
+    Args:
+        environment: str. Alerta environment to be used (e.g. 'Devel')
+        kafka_endpoints: str. kafka broker endpoint
+        kafka_topic: str. kafka topic to listen t
+        alerta_endpoint: str. Alerta api endpoint
+        alerta_token: str. Alerta api access token
+
+    """
+
+    # Initialize kafka
+    kafka_list = kafka_endpoints.split(',')
+
+    consumer = KafkaConsumer(kafka_topic,
+                             group_id='argo-alerta',
+                             bootstrap_servers=kafka_list)
+    for message in consumer:
+        read_and_send(message, environment, alerta_endpoint, alerta_token)
+
+
+def gocdb_to_contacts(gocdb_xml, use_notif_flag, test_emails):
+    """Transform gocdb xml schema info on generic contacts json information
+
+    Args:
+        gocdb_xml: str. Data in gocdb xml format
+        use_notif_flag: boolean. Examine or not notifications flag when gathering contacts
+
+    Return:
+        obj: Json representation of contact information
+    """
+    xmldoc = parseString(gocdb_xml)
+    contacts = []
+    clist = xmldoc.getElementsByTagName("CONTACT_EMAIL")
+
+    indx = 0
+    for item in clist:
+
+        # By default accept all contacts
+        notify_val = 'Y'
+        # If flag on accept only contacts with notification flag
+        if use_notif_flag:
+            notify = item.parentNode.getElementsByTagName('NOTIFICATIONS')[0]
+            # if notification flag is set to false skip
+            notify_val = notify.firstChild.nodeValue
+
+        if notify_val == 'TRUE' or notify_val == 'Y':
+            c = dict()
+            c["type"] = item.parentNode.tagName
+
+            # Check if name tag exists
+            name_tags = item.parentNode.getElementsByTagName("NAME")
+            # if not check short name tag
+            if len(name_tags) == 0:
+                name_tags = item.parentNode.getElementsByTagName("SHORT_NAME")
+
+            # if still no name related tag skip
+            if len(name_tags) == 0:
+                continue
+
+            c["name"] = name_tags[0].firstChild.nodeValue
+
+            if test_emails is None:
+                c["email"] = item.firstChild.nodeValue
+            else:
+                c["email"] = test_emails[indx % len(test_emails)]
+                indx = indx + 1
+
+            contacts.append(c)
+
+    return contacts
+
+
+def contacts_to_alerta(contacts):
+    """Transform a contacts json object to alerta's rule json object
+
+    Args:
+        contacts: obj. Json representation of contact information
+
+    Return:
+        obj: Json representation of alerta mailer rules
+    """
+    rules = []
+    for c in contacts:
+
+        rule_name = "rule_" + c["name"]
+        rule_fields = [{u"field": u"resource", u"regex": c["name"]}]
+        rule_contacts = [c["email"]]
+        rule_exlude = True
+        rule = {u"name": rule_name, u"fields": rule_fields, u"contacts": rule_contacts, u"exclude": rule_exlude}
+        rules.append(rule)
+
+    logging.info("Generated " + str(len(rules)) + " alerta rules from contact information")
+    return rules
+
+
+def get_gocdb(api_url, ca_bundle, hostcert, hostkey, verify):
+    """Http Rest call to gocdb-api to get xml contact information
+
+    Args:
+        api_url: str. Gocdb url call
+        ca_bundle: str. CA bundle file
+        hostcert: str. Host certificate file
+        hostkey: str. Host key file
+        verify: str. path to a ca_bundle for verification - if available
+
+    Return:
+        str: gocdb-api xml response
+    """
+
+    # If verify is true replace it with ca_bundle path
+    if verify:
+        verify = ca_bundle
+
+    logging.info("Requesting data from gocdb api: " + api_url)
+    r = requests.get(api_url, cert=(hostcert, hostkey), verify=verify)
+
+    if r.status_code == 200:
+        logging.info("Gocdb data retrieval successful")
+        return r.text.encode('utf-8').strip()
+
+    return ""
+
+
+def write_rules(rules, outfile):
+    """Writes alerta email rules to a specific output file
+
+    Args:
+        rules: obj. json representation of alerta rules
+        outfile: str. output filename path
+    """
+
+    json_str = json.dumps(rules, indent=4)
+    logging.info("Saving rule to file: " + outfile)
+    with open(outfile, "w") as output_file:
+        output_file.write(json_str)