devdazed · December 28, 2015 19:35 · Dec 28, 2015
diff --git a/jira-slack.py b/jira-slack.py
@@ -0,0 +1,276 @@
+#!/usr/bin/env python
+
+from __future__ import print_function
+
+import json
+import logging
+import re
+
+from base64 import b64decode, b64encode
+from urllib2 import Request, urlopen, URLError, HTTPError
+
+log = logging.getLogger(__name__)
+
+
+class SlackJiraLinkBot(object):
+    """
+    A Bot that scans slack messages for mentions of potential
+    JIRA Issues and responds with information about the Issue
+    """
+
+    # The domain for JIRA (eg. https://example.atlassian.net)
+    jira_domain = None
+
+    # The JIRA username to use for JIRA Basic Authentication.
+    jira_user = None
+
+    # The JIRA password to user for JIRA Basic Authentication
+    jira_password = None
+
+    # The REST API base path for JIRA Issues
+    # Default: /rest/api/2/issue/
+    jira_issue_path = '/rest/api/2/issue/'
+
+    # Regex used to detect when JIRA Issues are mentioned in a Slack Message
+    # Default: [A-Z]{2,}-\d+
+    jira_issue_regex = '[A-Z]{2,}-\d+'
+
+    # The Slack Incoming WebHook URL for sending messages
+    slack_webhook_url = None
+
+    # A list of valid slack tokens that come from any Slack Outgoing WebHooks
+    # An empty list will accept any token.
+    # Default: ()
+    slack_valid_tokens = ()
+
+    # Username to post Slack messages under. Note: does not need to be a real user.
+    # Default: JIRA
+    slack_user = 'JIRA'
+
+    # Icon URL for the Slack user.
+    # Default: (JIRA icon) https://slack.global.ssl.fastly.net/66f9/img/services/jira_128.png
+    slack_user_icon = 'https://slack.global.ssl.fastly.net/66f9/img/services/jira_128.png'
+
+    # Colors to use for JIRA issues.
+    # These should match the issue types you have set up in JIRA.
+    colors = {
+        'New Feature': '#65AC43',  # Apple
+        'Bug': '#D24331',          # Valencia
+        'Task': '#377DC6',         # Tufts Blue
+        'Sub-Task': '#377DC6',     # Tufts Blue
+        'Epic': '#654783',         # Gigas
+        'Question': '#707070',     # Dove Grey
+        'DEFAULT': '#F5F5F5'       # Wild Sand
+    }
+
+    def __init__(self, jira_domain, jira_user, jira_password, slack_webhook_url,
+                 slack_valid_tokens=slack_valid_tokens, jira_issue_path=jira_issue_path,
+                 jira_issue_regex=jira_issue_regex, slack_user=slack_user,
+                 slack_user_icon=slack_user_icon, colors=colors, log_level='INFO'):
+
+        self.jira_domain = jira_domain
+        self.jira_user = jira_user
+        self.jira_password = jira_password
+        self.slack_webhook_url = slack_webhook_url
+        self.slack_valid_tokens = slack_valid_tokens
+        self.jira_issue_path = jira_issue_path
+        self.jira_issue_regex = re.compile(jira_issue_regex)
+        self.slack_user = slack_user
+        self.slack_user_icon = slack_user_icon
+        self.colors = colors
+
+        log.setLevel(log_level)
+
+    @staticmethod
+    def _make_request(url, body=None, headers={}):
+        if 'https://' not in url:
+            url = 'https://' + url
+
+        req = Request(url, body, headers)
+        log.info('Making request to %s', url)
+
+        try:
+            response = urlopen(req)
+            body = response.read()
+            try:
+                return json.loads(body)
+            except ValueError:
+                return body
+
+        except HTTPError as e:
+            log.error("Request failed: %d %s", e.code, e.reason)
+        except URLError as e:
+            log.error("Server connection failed: %s", e.reason)
+
+    def _process_issue(self, key, channel):
+        """
+        Gets information for a JIRA issue and sends a message
+        to Slack with information about the issue.
+        :param key: The JIRA issue key (eg. JIRA-1234)
+        """
+        issue = self.jira_issue(key)
+        if issue is not None:
+            self.send_message(issue, channel)
+
+    def on_message(self, event):
+        """ Parses a message even coming from a Slack outgoing webhook then
+        determines if any JIRA issues exist in the message and send a Slack
+        notification to the channel with information about the issue
+        :param event: The Slack outgoing webhook payload
+        """
+        log.info('Processing Event: %s', event)
+
+        # Validate Slack Tokens
+        if self.slack_valid_tokens and event['token'] not in self.slack_valid_tokens:
+            log.error('Request token (%s) is invalid', event['token'])
+            raise Exception('Invalid request token')
+
+        # Find all JIRA issues in a message
+        message = event.get('text', '')
+        matches = self.jira_issue_regex.findall(message)
+
+        if len(matches) == 0:
+            log.info('No issues found in (%s)', message)
+            return
+
+        for key in matches:
+            self._process_issue(key, event['channel_name'])
+
+    def jira_issue(self, key):
+        """
+        Makes a call to the JIRA REST API to retrieve JIRA Issue information
+        :param key: The JIRA Issue key (eg. JIRA-1234)
+        :return: dict
+        """
+        url = self.jira_domain + self.jira_issue_path + key
+        auth = 'Basic ' + b64encode(self.jira_user + ':' + self.jira_password)
+        return self._make_request(url, headers={
+            'Authorization': auth,
+            'Content-Type': 'application/json'
+        })
+
+    def send_message(self, issue, channel):
+        """
+        Sends a Slack message with information about the JIRA Issue
+        :param issue: The JIRA Issue dict
+        :param channel: The Slack channel to send the message
+        """
+        # Ensure there is a '#' prepended to the Slack channel
+        channel = '#' + channel
+
+        # The color of the post, to match the issue type
+        color = self.colors.get(issue['fields']['issuetype']['name'], self.colors['DEFAULT'])
+
+        # The Title to the JIRA issue, (eg. JIRA-1234 - Add JIRA Slack Integration)
+        title = issue['key'] + ' - ' + issue['fields']['summary']
+
+        # The link to the JIRA issue show page
+        title_link = self.jira_domain + '/browse/' + issue['key']
+
+        # Text sent to Slack, replaces JIRA code blocks with Slack code blocks
+        # As a side effect this also replaces color blocks with Slack code blocks
+        text = re.sub('{.*}', '```', issue['fields']['description'])
+
+        # The priority name of the issue
+        priority = issue['fields']['priority']['name']
+
+        # The name of the person assigned to the issue
+        assignee = issue['fields']['assignee']['displayName']
+
+        # The status of the issue
+        status = issue['fields']['status']['name']
+
+        # create the body of the request.
+        body = json.dumps({
+            'channel': channel,
+            'username': self.slack_user,
+            'icon_url': self.slack_user_icon,
+            'attachments': [
+                {
+                    'fallback': title,
+                    'mrkdwn_in': ['text', 'pretext', 'fields'],
+                    'color': color,
+                    'title': title,
+                    'title_link': title_link,
+                    'text': text,
+                    'fields': [
+                        {'title': 'Priority', 'value': priority, 'short': True},
+                        {'title': 'Assignee', 'value': assignee, 'short': True},
+                        {'title': 'Status', 'value': status, 'short': True},
+                    ]
+                }
+            ]
+        })
+        self._make_request(self.slack_webhook_url, body)
+
+
+def lambda_handler(event, _):
+    """
+    Main entry point for AWS Lambda.
+
+    Variables can not be passed in to AWS Lambda, the configuration
+    parameters below are encrypted using AWS IAM Keys.
+
+    :param event: The event as it is received from AWS Lambda
+    """
+
+    # Boto is always available in AWS lambda, but may not be available in
+    # standalone mode
+    import boto3
+
+    # To generate the encrypted values, go to AWS IAM Keys and Generate a key
+    # Then grant decryption using the key to the IAM Role used for your lambda
+    # function.
+    #
+    # Then use the command `aws kms encrypt --key-id alias/<key-alias> --plaintext <value-to-encrypt>
+    # Put the encrypted value in the configuration dictionary below
+    encrypted_config = {
+        'jira_domain':        '<ENCRYPTED JIRA DOMAIN>',
+        'jira_user':          '<ENCRYPTED JIRA USER>',
+        'jira_password':      '<ENCRYPTED JIRA PASSWORD>',
+        'slack_webhook_url':  '<ENCRYPTED WEBHOOK URL>'
+    }
+
+    kms = boto3.client('kms')
+    config = {x: kms.decrypt(CiphertextBlob=b64decode(y))['Plaintext'] for x, y in encrypted_config.iteritems()}
+    bot = SlackJiraLinkBot(**config)
+    return bot.on_message(event)
+
+
+def main():
+    """
+    Runs the SlackJIRA bot as a standalone server.
+    """
+    from argparse import ArgumentParser
+    from flask import Flask, request
+
+    parser = ArgumentParser(usage=main.__doc__)
+    parser.add_argument("-p", "--port", dest="port", default=8675,
+                        help="Port to run bot server")
+    parser.add_argument("-jd", "--jira-domain", required=True, dest="jira_domain",
+                        help="Domain where your JIRA is located")
+    parser.add_argument("-ju", "--jira-user", required=True, dest="jira_user",
+                        help="The JIRA username for authenticating to the JIRA REST API")
+    parser.add_argument("-jp", "--jira-password", required=True, dest="jira_password",
+                        help="The JIRA password for authenticating to the JIRA REST API")
+    parser.add_argument("-su", "--slack-webhook-url", dest="slack_webhook_url",
+                        help="URL for incoming Slack WebHook")
+
+    app = Flask(__name__)
+    app.config['PROPAGATE_EXCEPTIONS'] = True
+
+    args = vars(parser.parse_args())
+    port = args.pop('port')
+    bot = SlackJiraLinkBot(**args)
+
+    log.addHandler(logging.StreamHandler())
+
+    @app.route('/', methods=('POST',))
+    def handle():
+        bot.on_message(request.form.to_dict())
+        return 'OK'
+
+    app.run(port=port)
+
+if __name__ == '__main__':
+    main()