├── README.md
├── README
    ├── alert_actions.conf.spec
    └── savedsearches.conf.spec
├── appserver
    └── static
    │   ├── appIcon.png
    │   └── jira_alert_action.png
├── bin
    ├── TEST_README.txt
    ├── generate_jira_dialog.py
    ├── jira.py
    ├── jira_alerts_install_endpoint.py
    ├── jira_helpers.py
    ├── jira_test.json
    └── jira_test.py
├── build
    └── build.sh
├── default
    ├── alert_actions.conf
    ├── app.conf
    ├── data
    │   └── ui
    │   │   └── alerts
    │   │       └── jira.html
    ├── restmap.conf
    └── setup.xml
└── metadata
    └── default.meta


/README.md:
--------------------------------------------------------------------------------
 1 | # JIRA Alert Add-on
 2 | 
 3 | ## Introduction
 4 | 
 5 | This add-on allows Splunk to create JIRA issues as an alert action.
 6 | 
 7 | This add-on was produced as part of the
 8 | [Developer Guidance](http://dev.splunk.com/goto/alerting) project. Read our
 9 | guide to learn more about creating custom actions that can be performed when an
10 | alert triggers.
11 | 
12 | ## Installation
13 | 
14 | Once the app is installed (through [Splunkbase](https://splunkbase.splunk.com),
15 | `Install app from file`, or by copying this directory to the etc/apps/ directory
16 | of your Splunk installation), go to the app management page in the Splunk
17 | interface. Click `Set up` in the JIRA Ticket Creation row. Fill out the required
18 | attributes for your JIRA installation and you are ready to go.
19 | 
20 | To add a JIRA action to an alert, go to the `Alerts` tab in the `Search` app and
21 | find the alert for which you want to add JIRA tickets. Click `Edit`, and select
22 | `Edit Actions`. Click `+ Add Actions` and select JIRA. Fill out the attributes
23 | for the artifact you wish to create in JIRA when the associated search returns
24 | results, and Splunk will start logging bugs for you.
25 | 
26 | ## Case Study
27 | For a case study showcasing the application of this custom alert action, see the [Splunk Reference App - PAS](https://github.com/splunk/splunk-ref-pas-code) and the accompanying [Splunk Developer Guidance](http://dev.splunk.com/goto/devguide)
28 | 
29 | ## License
30 | The Splunk Add-on for Atlassian JIRA Alerts is licensed under the Apache License 2.0. Details can be found in the [LICENSE page](http://www.apache.org/licenses/LICENSE-2.0).
31 | 


--------------------------------------------------------------------------------
/README/alert_actions.conf.spec:
--------------------------------------------------------------------------------
1 | [jira]
2 | param.jira_url = <string>
3 | param.jira_username = <string>
4 | param.jira_password = <string>
5 | 


--------------------------------------------------------------------------------
/README/savedsearches.conf.spec:
--------------------------------------------------------------------------------
1 | # JIRA alert settings
2 | action.jira = [0|1]
3 | action.jira.param.project_key = <string>
4 | action.jira.param.summary = <string>
5 | action.jira.param.description = <string>
6 | action.jira.param.issue_type = <string>
7 | action.jira.param.assignee = <string>
8 | 


--------------------------------------------------------------------------------
/appserver/static/appIcon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/splunk/splunk-add-on-jira-alerts/bc316b61e4cad709ba4573fa067730b1bcdad6e0/appserver/static/appIcon.png


--------------------------------------------------------------------------------
/appserver/static/jira_alert_action.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/splunk/splunk-add-on-jira-alerts/bc316b61e4cad709ba4573fa067730b1bcdad6e0/appserver/static/jira_alert_action.png


--------------------------------------------------------------------------------
/bin/TEST_README.txt:
--------------------------------------------------------------------------------
 1 | Prerequisites:
 2 |     * The jira_alerts add-on has been installed to $SPLUNK_HOME/etc/apps
 3 |     * The admin or a user with sufficient privileges has completed the initial
 4 |       set up of the Alert Action (Settings->Alert Actions->Setup JIRA Ticket Creation).
 5 | 
 6 | I. Unit Test Usage:
 7 |     1. In shell, navigate to $SPLUNK_HOME/etc/apps/jira_alerts/bin
 8 |     2. Open jira_test.py and set Splunk instance bits
 9 |     3. In shell, execute "splunk cmd python jira_test.py"
10 | 
11 |     Expected Result:
12 |         All tests pass.  If a specific tests fails, it will be indicated
13 |         in the output of the script in the shell.
14 | 
15 | II. Shell-level Invocation
16 |     1. In shell, navigate to $SPLUNK_HOME/etc/apps/jira_alerts/bin
17 |     2. Open jira_test.json and fill in relevant bits.
18 |     3. Execute "cat jira_test.json | splunk cmd python jira.py --execute"
19 | 
20 |     Expected Result:
21 |         A new issue will have been created in the target JIRA instance.
22 | 
23 | III. Ad-hoc Search Language Invocation
24 |     In a SplunkWeb Search Dashboard, enter the following (after setting bits
25 |     specific to your JIRA instance):
26 |         | sendalert jira param.jira_url="SET_JIRA_URL" param.jira_username="SET_JIRA_USERNAME" param.priority="High" param.project_key="SET_JIRA_PROJECT_KEY" param.summary="Test Summary" param.issue_type="Task" param.description="Test Description"
27 |         
28 |     Expected Result:
29 |         A new issue will have been created in the target JIRA instance.


--------------------------------------------------------------------------------
/bin/generate_jira_dialog.py:
--------------------------------------------------------------------------------
 1 | import requests
 2 | import cgi
 3 | from jira_helpers import *
 4 | 
 5 | TEMPLATE = '''
 6 | <form class="form-horizontal form-complex">
 7 |     <div class="control-group">
 8 |         <label class="control-label" for="project_key">Project</label>
 9 | 
10 |         <div class="controls">
11 |             <select name="action.jira.param.project_key" id="project_key">
12 |                 %(project_choices)s
13 |             </select>
14 |             <span class="help-block">Enter the project key to create Issues under.</span>
15 |         </div>
16 |     </div>
17 |     <div class="control-group">
18 |         <label class="control-label" for="issue_type">Type</label>
19 | 
20 |         <div class="controls">
21 |             <select name="action.jira.param.issue_type" id="issue_type">
22 |                 %(issuetype_choices)s
23 |             </select>
24 |             <span class="help-block">Enter an Issue type.</span>
25 |         </div>
26 |     </div>
27 |     <div class="control-group">
28 |         <label class="control-label" for="jira_priority">Priority</label>
29 | 
30 |         <div class="controls">
31 |             <select name="action.jira.param.priority" id="jira_priority">
32 |                 %(priority_choices)s
33 |             </select>
34 |             <span class="help-block">Select the issue priority.</span>
35 |         </div>
36 |     </div>
37 |     <div class="control-group">
38 |         <label class="control-label" for="summary">Summary</label>
39 | 
40 |         <div class="controls">
41 |             <input type="text" name="action.jira.param.summary" id="summary" />
42 |             <span class="help-block">Enter a summary of the Issue.</span>
43 |         </div>
44 |     </div>
45 |     <div class="control-group">
46 |         <label class="control-label" for="description">Description</label>
47 | 
48 |         <div class="controls">
49 |             <textarea name="action.jira.param.description" id="description" style="height: 120px;"></textarea>
50 |             <span class="help-block">
51 |                 Enter a description of the issue. This text can include tokens that will resolve to text based on search results.
52 |                 <a href="{{SPLUNKWEB_URL_PREFIX}}/help?location=learnmore.alert.action.tokens" target="_blank"
53 |                    title="Splunk help">Learn More <i class="icon-external"></i></a>
54 |             </span>
55 |         </div>
56 |     </div>
57 | </form>
58 | '''
59 | 
60 | def generate_jira_dialog(jira_settings, server_uri, session_key):
61 |     new_content = TEMPLATE % dict(
62 |         project_choices="\n\t\t".join(map(lambda project: select_choice(value=project.get('key'), label='%(key)s - %(name)s' % project), get_projects(jira_settings))),
63 |         issuetype_choices="\n\t\t".join(map(lambda issuetype: select_choice(value=issuetype.get('name'), label='%(name)s' % issuetype), get_issuetypes(jira_settings))),
64 |         priority_choices="\n\t\t".join(map(lambda issuetype: select_choice(value=issuetype.get('name'), label='%(name)s' % issuetype), get_priorities(jira_settings))),
65 |     )
66 |     update_jira_dialog(new_content, server_uri, session_key)
67 | 
68 | 
69 | def get_projects(jira_settings):
70 |     response = requests.get(
71 |         url=jira_url(jira_settings, '/project'),
72 |         auth=(jira_settings.get('jira_username'), jira_settings.get('jira_password')),
73 |         verify=False)
74 |     return response.json()
75 | 
76 | def get_issuetypes(jira_settings):
77 |     response = requests.get(
78 |         url=jira_url(jira_settings, '/issuetype'),
79 |         auth=(jira_settings.get('jira_username'), jira_settings.get('jira_password')),
80 |         verify=False)
81 |     return response.json()
82 | 
83 | def get_priorities(jira_settings):
84 |     response = requests.get(
85 |         url=jira_url(jira_settings, '/priority'),
86 |         auth=(jira_settings.get('jira_username'), jira_settings.get('jira_password')),
87 |         verify=False)
88 |     return response.json()
89 | 
90 | 
91 | def select_choice(value, label):
92 |     # TODO: XML escape content
93 |     return '<option value="%s">%s</option>' % (cgi.escape(value), cgi.escape(label))
94 | 
95 | 


--------------------------------------------------------------------------------
/bin/jira.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | import json
 3 | import requests
 4 | from jira_helpers import get_jira_password
 5 | 
 6 | # creates outbound message from alert payload contents
 7 | # and attempts to send to the specified endpoint
 8 | def send_message(payload):
 9 |     config = payload.get('configuration')
10 | 
11 |     ISSUE_REST_PATH = "/rest/api/latest/issue"
12 |     url = config.get('jira_url')
13 |     jira_url = url + ISSUE_REST_PATH
14 |     username = config.get('jira_username')
15 |     password = get_jira_password(payload.get('server_uri'), payload.get('session_key'))
16 | 
17 |     # create outbound JSON message body
18 |     body = json.dumps({
19 |         "fields": {
20 |             "project": {
21 |                 "key" : config.get('project_key')
22 |             },
23 |             "summary": config.get('summary'),
24 |             "description": config.get('description'),
25 |             "issuetype": {
26 |                 "name": config.get('issue_type')
27 |             }
28 |         }
29 |     })
30 | 
31 |     # create outbound request object
32 |     try:
33 |         headers = {"Content-Type": "application/json"}
34 |         result = requests.post(url=jira_url, data=body, headers=headers, auth=(username, password))
35 |         print >>sys.stderr, "INFO Jira server HTTP status= %s" % result.text
36 |         print >>sys.stderr, "INFO Jira server response: %s" % result.text
37 |     except Exception, e:
38 |         print >> sys.stderr, "ERROR Error sending message: %s" % e
39 |         return False
40 | 
41 | if __name__ == "__main__":
42 |     if len(sys.argv) > 1 and sys.argv[1] == "--execute":
43 |         try:
44 |             # retrieving message payload from splunk
45 |             raw_payload = sys.stdin.read()
46 |             payload = json.loads(raw_payload)
47 |             send_message(payload)
48 |         except Exception, e:
49 |             print >> sys.stderr, "ERROR Unexpected error: %s" % e
50 |             sys.exit(3)
51 |     else:
52 |         print >> sys.stderr, "FATAL Unsupported execution mode (expected --execute flag)"
53 |         sys.exit(1)
54 | 


--------------------------------------------------------------------------------
/bin/jira_alerts_install_endpoint.py:
--------------------------------------------------------------------------------
 1 | import splunk
 2 | import splunk.admin as admin
 3 | from generate_jira_dialog import generate_jira_dialog
 4 | from jira_helpers import *
 5 | 
 6 | PASSWORD_PLACEHOLDER = '*******'
 7 | DEFAULT_SETTINGS = ('project_key', 'issue_type', 'priority')
 8 | 
 9 | class JiraAlertsInstallHandler(admin.MConfigHandler):
10 |     def __init__(self, *args):
11 |         admin.MConfigHandler.__init__(self, *args)
12 |         self.shouldAutoList = False
13 | 
14 |     def setup(self):
15 |         self.supportedArgs.addOptArg('*')
16 | 
17 |     def handleList(self, confInfo):
18 |         jira_settings = get_jira_settings(splunk.getLocalServerInfo(), self.getSessionKey())
19 |         item = confInfo['jira']
20 |         item['jira_url'] = jira_settings.get('jira_url', 'http://your.server/')
21 |         item['jira_username'] = jira_settings.get('jira_username')
22 |         item['jira_password'] = PASSWORD_PLACEHOLDER
23 |         for k in DEFAULT_SETTINGS:
24 |             item['default_' + k] = jira_settings.get(k, '')
25 |         item['import'] = '0'
26 | 
27 |     def handleEdit(self, confInfo):
28 |         if self.callerArgs.id == 'jira':
29 |             jira_settings = get_jira_settings(splunk.getLocalServerInfo(), self.getSessionKey())
30 |             if 'jira_url' in self.callerArgs:
31 |                 jira_settings['jira_url'] = self.callerArgs['jira_url'][0]
32 |             if 'jira_username' in self.callerArgs:
33 |                 jira_settings['jira_username'] = self.callerArgs['jira_username'][0]
34 |             if 'jira_password' in self.callerArgs:
35 |                 password = self.callerArgs['jira_password'][0]
36 |                 if password and password != PASSWORD_PLACEHOLDER:
37 |                     jira_settings['jira_password'] = password
38 |             for k in DEFAULT_SETTINGS:
39 |                 if 'default_' + k in self.callerArgs:
40 |                     jira_settings[k] = self.callerArgs['default_' + k][0]
41 |             if not validate_jira_settings(jira_settings):
42 |                 raise admin.ArgValidationException, "Error connecting to JIRA server"
43 |             update_jira_settings(jira_settings, splunk.getLocalServerInfo(), self.getSessionKey())
44 |             if 'import' in self.callerArgs and self.callerArgs['import'][0] in ('1', 'true'):
45 |                 try:
46 |                     generate_jira_dialog(jira_settings, splunk.getLocalServerInfo(), self.getSessionKey())
47 |                 except Exception, e:
48 |                     raise admin.AdminManagerException("Error importing settings from Jira, check server URL and credentials: " + str(e))
49 | 
50 | 
51 | admin.init(JiraAlertsInstallHandler, admin.CONTEXT_APP_ONLY)
52 | 


--------------------------------------------------------------------------------
/bin/jira_helpers.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | import requests
 3 | import json
 4 | 
 5 | def splunkd_auth_header(session_key):
 6 |     return {'Authorization': 'Splunk ' + session_key}
 7 | 
 8 | def get_jira_settings(server_uri, session_key):
 9 |     result = dict()
10 |     for k,v in get_jira_action_config(server_uri, session_key).items():
11 |         if k.startswith('param.'):
12 |             result[k[len('param.'):]] = v
13 |     result['jira_password'] = get_jira_password(server_uri, session_key)
14 |     return result
15 | 
16 | def validate_jira_settings(jira_settings):
17 |     url = jira_url(jira_settings, '/myself')
18 |     requests.get(
19 |         url=url,
20 |         auth=(jira_settings.get('jira_username'), jira_settings.get('jira_password')),
21 |         verify=False,
22 |         timeout=10
23 |     ).json()
24 |     return True
25 | 
26 | def update_jira_settings(jira_settings, server_uri, session_key):
27 |     r = requests.post(
28 |         url=server_uri+'/servicesNS/nobody/splunk-add-on-jira-alerts/alerts/alert_actions/jira?output_mode=json',
29 |         data={
30 |             'param.jira_url': jira_settings.get('jira_url'),
31 |             'param.jira_username': jira_settings.get('jira_username'),
32 |             'param.project_key': jira_settings.get('project_key', ''),
33 |             'param.issue_type': jira_settings.get('issue_type', ''),
34 |             'param.priority': jira_settings.get('priority', '')
35 |         },
36 |         headers=splunkd_auth_header(session_key),
37 |         verify=False).json()
38 |     requests.post(
39 |         url=server_uri + '/servicesNS/nobody/splunk-add-on-jira-alerts/storage/passwords/%3Ajira_password%3A?output_mode=json',
40 |         data={
41 |             'password': jira_settings.get('jira_password')
42 |         },
43 |         headers=splunkd_auth_header(session_key),
44 |         verify=False)
45 | 
46 | def get_jira_password(server_uri, session_key):
47 |     password_url = server_uri + '/servicesNS/nobody/splunk-add-on-jira-alerts/storage/passwords/%3Ajira_password%3A?output_mode=json'
48 | 
49 |     try:
50 |         # attempting to retrieve cleartext password, disabling SSL verification for practical reasons
51 |         result = requests.get(url=password_url, headers=splunkd_auth_header(session_key), verify=False)
52 |         if result.status_code != 200:
53 |             print >> sys.stderr, "ERROR Error: %s" % str(result.json())
54 |     except Exception, e:
55 |         print >> sys.stderr, "ERROR Error sending message: %s" % e
56 |         return False
57 | 
58 |     splunk_response = json.loads(result.text)
59 |     jira_password = splunk_response.get("entry")[0].get("content").get("clear_password")
60 | 
61 |     return jira_password
62 | 
63 | def get_jira_username(server_uri, session_key):
64 |     return get_jira_action_config(server_uri, session_key).get('jira_username')
65 | 
66 | def get_jira_action_config(server_uri, session_key):
67 |     url = server_uri + '/servicesNS/nobody/splunk-add-on-jira-alerts/alerts/alert_actions/jira?output_mode=json'
68 |     result = requests.get(url=url, headers=splunkd_auth_header(session_key), verify=False)
69 |     return json.loads(result.text)['entry'][0]['content']
70 | 
71 | def jira_url(jira_settings, endpoint):
72 |     return '%s/rest/api/latest%s' % (jira_settings.get('jira_url'), endpoint)
73 | 
74 | def update_jira_dialog(content, server_uri, session_key):
75 |     uri = server_uri + '/servicesNS/nobody/splunk-add-on-jira-alerts/data/ui/alerts/jira'
76 |     requests.post(url=uri, data={'eai:data': content}, headers=splunkd_auth_header(session_key), verify=False)
77 | 


--------------------------------------------------------------------------------
/bin/jira_test.json:
--------------------------------------------------------------------------------
 1 | {  
 2 |    "app":"pas_ref_app",
 3 |    "owner":"system",
 4 |    "results_file":"",
 5 |    "results_link":"",
 6 |    "server_host":"localhost",
 7 |    "server_uri":"https://127.0.0.1:8089",
 8 |    "session_key":"SET_SESSION_KEY",
 9 |    "sid":"",
10 |    "search_name":"",
11 |    "configuration":{  
12 |       "description":"Test Description",
13 |       "issue_type":"Task",
14 |       "jira_url":"SET_JIRA_URL",
15 |       "jira_username":"SET_USERNAME",
16 |       "priority":"",
17 |       "project_key":"SET_PROJECT_KEY",
18 |       "summary":"Test Summary"
19 |    },
20 |    "result":null
21 | }


--------------------------------------------------------------------------------
/bin/jira_test.py:
--------------------------------------------------------------------------------
  1 | import splunk
  2 | import requests
  3 | import json
  4 | import sys
  5 | import unittest
  6 | from xml.dom import minidom
  7 | from jira_helpers import *
  8 | 
  9 | '''
 10 |     This unit test checks:
 11 |         * The validity of a sample JSON payload intended to
 12 |           be sent to JIRA.
 13 | 
 14 |         * The ability of the JIRA Add-on to pull a JIRA username
 15 |           & password from the indicated Splunk instance.
 16 | 
 17 |     Asserts that necessary default values have been changed
 18 |     and for the existence of required keys.
 19 |     
 20 |     Set values for SPLUNK_URL, SPLUNK_USERNAME & SPLUNK_PASSWORD
 21 |     prior to executing unit tests.
 22 | '''
 23 | class TestJiraClass(unittest.TestCase):
 24 |     SPLUNK_URL = ""
 25 |     SPLUNK_USERNAME = ""
 26 |     SPLUNK_PASSWORD = ""
 27 | 
 28 |     @classmethod
 29 |     def setUpClass(cls):
 30 |         if cls.SPLUNK_URL is "" or cls.SPLUNK_USERNAME is "" or cls.SPLUNK_PASSWORD is "":
 31 |             print >> sys.stdout, "Please set Splunk configuration bits before executing test script."
 32 |             sys.exit(1)
 33 | 
 34 |         try:
 35 |             # loading sample payload JSON
 36 |             with open('jira_test.json') as data_file:
 37 |                 cls.payload = json.load(data_file)
 38 |                 cls.config = cls.payload.get('configuration')
 39 | 
 40 |             # obtaining splunk session key
 41 |             result = requests.post(url=cls.SPLUNK_URL + "/services/auth/login", data={'username':cls.SPLUNK_USERNAME, 'password':cls.SPLUNK_PASSWORD}, headers={}, verify=False)
 42 |             cls.session_key = minidom.parseString(result.text).getElementsByTagName('sessionKey')[0].childNodes[0].nodeValue
 43 |         except Exception, e:
 44 |             print >> sys.stderr, "ERROR Unable to parse JSON file.  Error: %s" % e
 45 | 
 46 | class TestJiraPayload(TestJiraClass):
 47 |     @classmethod
 48 |     def setUpClass(cls):
 49 |         super(TestJiraPayload, cls).setUpClass()
 50 | 
 51 |     # verifies that a JIRA username has been set in the Splunk instance
 52 |     def test_jira_username(self):
 53 |         username = get_jira_action_config(self.SPLUNK_URL, self.session_key).get('param.jira_username')
 54 |         self.assertNotEqual(username,None)
 55 | 
 56 |     # verifies that a JIRA password has been set in the Splunk instance
 57 |     def test_jira_password(self):
 58 |         self.assertNotEqual(get_jira_password(self.SPLUNK_URL, self.session_key),None)
 59 | 
 60 |     # Begin tests for correct values in the sample JSON payload
 61 |     def test_app(self):
 62 |         self.assertEqual(self.payload.get('app'),"pas_ref_app")
 63 | 
 64 |     def test_owner(self):
 65 |         self.assertEqual(self.payload.get('owner'),"system")
 66 | 
 67 |     def test_results_file(self):
 68 |         self.assertEqual(self.payload.get('results_file'),"")
 69 | 
 70 |     def test_results_link(self):
 71 |         self.assertEqual(self.payload.get('results_link'),"")
 72 | 
 73 |     def test_server_host(self):
 74 |         self.assertNotEqual(self.payload.get('server_host'),None)
 75 | 
 76 |     def test_server_uri(self):
 77 |         self.assertNotEqual(self.payload.get('server_uri'),None)
 78 | 
 79 |     def test_default_session(self):
 80 |         self.assertNotEqual(self.payload.get('session_key'),"SET_SESSION_KEY")
 81 | 
 82 |     def test_sid(self):
 83 |         self.assertEqual(self.payload.get('sid'),"")
 84 | 
 85 |     def test_search_name(self):
 86 |         self.assertEqual(self.payload.get('search_name'),"")
 87 | 
 88 |     def test_description(self):
 89 |         self.assertNotEqual(self.config.get('description'),None)
 90 | 
 91 |     def test_issue_type(self):
 92 |         self.assertNotEqual(self.config.get('issue_type'),None)
 93 | 
 94 |     def test_jira_url(self):
 95 |         self.assertNotEqual(self.config.get('jira_url'),"SET_JIRA_URL")
 96 | 
 97 |     def test_default_jira_username(self):
 98 |         self.assertNotEqual(self.config.get('jira_username'),"SET_USERNAME")
 99 | 
100 |     def test_jira_priority(self):
101 |         self.assertNotEqual(self.config.get('priority'),None)
102 | 
103 |     def test_jira_project_key(self):
104 |         self.assertNotEqual(self.config.get('jira_username'),"SET_PROJECT_KEY")
105 | 
106 |     def test_jira_summary(self):
107 |         self.assertNotEqual(self.config.get('summary'),None)
108 | 
109 |     def test_result(self):
110 |         self.assertEqual(self.payload.get('result'),None)
111 | 
112 | if __name__ == '__main__':
113 |     unittest.main()


--------------------------------------------------------------------------------
/build/build.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | BASEDIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )/.." && pwd )
 4 | FILENAME_BASE=${BASEDIR##*/}
 5 | VERSION=`grep version ${BASEDIR}/default/app.conf | sed 's/.*=\s*\([1-9\.]*\)/\1/' | tr -d '[:space:]'`
 6 | GIT_BRANCH=$(git rev-parse --abbrev-ref HEAD)
 7 | 
 8 | if [ "$GIT_BRANCH" = "master" ]
 9 | then
10 |     FILENAME="${FILENAME_BASE}-${VERSION}.spl"
11 | else
12 |     CURRENT_COMMIT=$(git rev-parse --short HEAD)
13 |     FILENAME="${FILENAME_BASE}-${GIT_BRANCH}-${CURRENT_COMMIT}-${VERSION}.spl"
14 | fi
15 | 
16 | cd $BASEDIR
17 | git archive --prefix="${FILENAME_BASE}/" --format tar.gz -o "${FILENAME}" ${GIT_BRANCH}
18 | echo "Created Splunk app archive at"
19 | echo "  ${PWD}/${FILENAME}"
20 | 


--------------------------------------------------------------------------------
/default/alert_actions.conf:
--------------------------------------------------------------------------------
1 | [jira]
2 | is_custom = 1
3 | disabled = 0
4 | label = JIRA
5 | description = Opens an Issue in JIRA
6 | icon_path = jira_alert_action.png
7 | payload_format = json
8 | 


--------------------------------------------------------------------------------
/default/app.conf:
--------------------------------------------------------------------------------
 1 | # Splunk Add-on for JIRA alerts
 2 | # Splunk app configuration file
 3 | #
 4 | 
 5 | [package]
 6 | check_for_updates = 1
 7 | id = splunk-add-on-jira-alerts
 8 | 
 9 | [install]
10 | is_configured = 0
11 | 
12 | [ui]
13 | is_visible = false
14 | label = JIRA Custom Alert Action : Ticket Creation
15 | 
16 | [launcher]
17 | description = Splunk Add-on for Atlassian JIRA. Includes a custom alert action.
18 | version = 0.9.0
19 | author = Splunk Dev (gmelnik)
20 | 
21 | [credential::jira_password:]
22 | 


--------------------------------------------------------------------------------
/default/data/ui/alerts/jira.html:
--------------------------------------------------------------------------------
 1 | <form class="form-horizontal form-complex">
 2 |     <div class="control-group">
 3 |         <label class="control-label" for="project_key">Project Key</label>
 4 | 
 5 |         <div class="controls">
 6 |             <input type="text" name="action.jira.param.project_key" id="project_key" />
 7 |             <span class="help-block">Enter the project key to create Issues under.</span>
 8 |         </div>
 9 |     </div>
10 |     <div class="control-group">
11 |         <label class="control-label" for="issue_type">Issue Type</label>
12 | 
13 |         <div class="controls">
14 |             <input type="text" name="action.jira.param.issue_type" id="issue_type" />
15 |             <span class="help-block">Enter an Issue type.</span>
16 |         </div>
17 |     </div>
18 |     <div class="control-group">
19 |         <label class="control-label" for="summary">Issue Summary</label>
20 | 
21 |         <div class="controls">
22 |             <input type="text" name="action.jira.param.summary" id="summary" />
23 |             <span class="help-block">Enter a summary of the Issue.</span>
24 |         </div>
25 |     </div>
26 |     <div class="control-group">
27 |         <label class="control-label" for="description">Description</label>
28 | 
29 |         <div class="controls">
30 |             <textarea name="action.jira.param.description" id="description" style="height: 120px;"></textarea>
31 |             <span class="help-block">
32 |                 Enter a description of the issue. This text can include tokens that will resolve to text based on search results.
33 |                 <a href="{{SPLUNKWEB_URL_PREFIX}}/help?location=learnmore.alert.action.tokens" target="_blank"
34 |                    title="Splunk help">Learn More <i class="icon-external"></i></a>
35 |             </span>
36 |         </div>
37 |     </div>
38 | </form>


--------------------------------------------------------------------------------
/default/restmap.conf:
--------------------------------------------------------------------------------
1 | [admin_external:jira_alerts_install]
2 | handlertype=python
3 | handlerfile=jira_alerts_install_endpoint.py
4 | handleractions=list, edit
5 | 
6 | 


--------------------------------------------------------------------------------
/default/setup.xml:
--------------------------------------------------------------------------------
 1 | <setup>
 2 |     <block title="JIRA Alert Actions">
 3 |         <text>Configure JIRA Alert Actions</text>
 4 |     </block>
 5 | 
 6 |     <block title="Server" endpoint="admin/jira_alerts_install" entity="jira">
 7 |         <input field="jira_url">
 8 |             <label>Server Base URL</label>
 9 |             <type>text</type>
10 |         </input>
11 |         <input field="jira_username">
12 |             <label>JIRA Username</label>
13 |             <type>text</type>
14 |         </input>
15 |         <input field="jira_password">
16 |             <label>JIRA Password</label>
17 |             <type>password</type>
18 |         </input>
19 |     </block>
20 |     <block title="Import Projects and Issue Types" endpoint="admin/jira_alerts_install" entity="jira">
21 |         <input field="import">
22 |             <label>Import information from JIRA server</label>
23 |             <type>bool</type>
24 |         </input>
25 |         <text>After submitting the setup with the checkbox enabled, Splunk will fetch all projects and issue types from your JIRA server, so it can be selected when creating an alert.</text>
26 |     </block>
27 |     <block title="Default Settings" endpoint="admin/jira_alerts_install" entity="jira">
28 |         <input field="default_project_key">
29 |             <label>Default Project</label>
30 |             <type>text</type>
31 |         </input>
32 |         <input field="default_issue_type">
33 |             <label>Default Issue Type</label>
34 |             <type>text</type>
35 |         </input>
36 |         <input field="default_priority">
37 |             <label>Default Priority</label>
38 |             <type>text</type>
39 |         </input>
40 |     </block>
41 | </setup>
42 | 


--------------------------------------------------------------------------------
/metadata/default.meta:
--------------------------------------------------------------------------------
 1 | []
 2 | access = read : [ * ], write : [ admin ]
 3 | 
 4 | [alert_actions/jira]
 5 | export = system
 6 | 
 7 | [alerts]
 8 | export = system
 9 | 
10 | [restmap]
11 | export = system


--------------------------------------------------------------------------------