SNOW-153244 setup actions (#170)

Author: sfc-gh-mmacintyre

.github/actions/gajira-create/README.md

@@ -0,0 +1,5 @@
+# Create a jira issue from a GH issue
+
+Stolen from [gajira-create](https://github.com/atlassian/gajira-create) and modified to support required custom fields in use at snowflake.
+
+Most of the dependencies (gajira-login, etc) have been folded into this action

.github/actions/gajira-create/action.js

@@ -0,0 +1,106 @@
+const _ = require('lodash')
+const Jira = require('./common/net/Jira')
+
+module.exports = class {
+  constructor ({ githubEvent, argv, config }) {
+    this.Jira = new Jira({
+      baseUrl: config.baseUrl,
+      token: config.token,
+      email: config.email,
+    })
+
+    this.config = config
+    this.argv = argv
+    this.githubEvent = githubEvent
+  }
+
+  async execute () {
+    this.preprocessArgs()
+
+    const { argv } = this
+    const projectKey = argv.project
+    const issuetypeName = argv.issuetype
+
+    // map custom fields
+    const { projects } = await this.Jira.getCreateMeta({
+      expand: 'projects.issuetypes.fields',
+      projectKeys: projectKey,
+      issuetypeNames: issuetypeName,
+    })
+
+    if (projects.length === 0) {
+      console.error(`project '${projectKey}' not found`)
+
+      return
+    }
+
+    const [project] = projects
+
+    if (project.issuetypes.length === 0) {
+      console.error(`issuetype '${issuetypeName}' not found`)
+
+      return
+    }
+
+    let providedFields = [{
+      key: 'project',
+      value: {
+        key: projectKey,
+      },
+    }, {
+      key: 'issuetype',
+      value: {
+        name: issuetypeName,
+      },
+    }, {
+      key: 'summary',
+      value: argv.summary,
+    }]
+
+    if (argv.assignee) {
+      providedFields.push({
+        key: 'assignee',
+        value: {
+            name: argv.assignee
+            }
+      })
+    }
+
+    if (argv.area) {
+      providedFields.push({
+        key: 'customfield_11401',
+        value: {
+            value: argv.area
+            }
+      })
+    }
+
+    if (argv.description) {
+      providedFields.push({
+        key: 'description',
+        value: argv.description,
+      })
+    }
+
+    const payload = providedFields.reduce((acc, field) => {
+      acc.fields[field.key] = field.value
+
+      return acc
+    }, {
+      fields: {},
+    })
+
+    const issue = await this.Jira.createIssue(payload)
+
+    return { issue: issue.key }
+  }
+
+  preprocessArgs () {
+    _.templateSettings.interpolate = /{{([\s\S]+?)}}/g
+    const summaryTmpl = _.template(this.argv.summary)
+    const descriptionTmpl = _.template(this.argv.description)
+
+    this.argv.summary = summaryTmpl({ event: this.githubEvent })
+    this.argv.description = descriptionTmpl({ event: this.githubEvent })
+  }
+}

.github/actions/gajira-create/action.yml

@@ -0,0 +1,24 @@
+name: Jira Create issue
+description: Create a new Jira issue
+branding:
+  icon: 'check-square'
+  color: 'blue'
+inputs:
+  project:
+    description: Key of the project
+    required: true
+  issuetype:
+    description: "Type of the issue to be created. Example: 'Incident'"
+    required: true
+  summary:
+    description: Issue summary
+    required: true
+  description:
+    description: Issue description
+    required: false
+outputs:
+  issue:
+    description: Key of the newly created issue
+runs:
+  using: 'node12'
+  main: 'dist/index.js'

.github/actions/gajira-create/common/net/Jira.js

@@ -0,0 +1,118 @@
+const { get } = require('lodash')
+
+const serviceName = 'jira'
+const { format } = require('url')
+const client = require('./client')(serviceName)
+
+class Jira {
+  constructor ({ baseUrl, token, email }) {
+    this.baseUrl = baseUrl
+    this.token = token
+    this.email = email
+  }
+
+  async getCreateMeta (query) {
+    return this.fetch('getCreateMeta', { pathname: '/rest/api/2/issue/createmeta', query })
+  }
+
+  async createIssue (body) {
+    return this.fetch('createIssue',
+      { pathname: '/rest/api/2/issue' },
+      { method: 'POST', body })
+  }
+
+  async getIssue (issueId, query = {}) {
+    const { fields = [], expand = [] } = query
+
+    try {
+      return this.fetch('getIssue', {
+        pathname: `/rest/api/2/issue/${issueId}`,
+        query: {
+          fields: fields.join(','),
+          expand: expand.join(','),
+        },
+      })
+    } catch (error) {
+      if (get(error, 'res.status') === 404) {
+        return
+      }
+
+      throw error
+    }
+  }
+
+  async getIssueTransitions (issueId) {
+    return this.fetch('getIssueTransitions', {
+      pathname: `/rest/api/2/issue/${issueId}/transitions`,
+    }, {
+      method: 'GET',
+    })
+  }
+
+  async transitionIssue (issueId, data) {
+    return this.fetch('transitionIssue', {
+      pathname: `/rest/api/3/issue/${issueId}/transitions`,
+    }, {
+      method: 'POST',
+      body: data,
+    })
+  }
+
+  async fetch (apiMethodName,
+    { host, pathname, query },
+    { method, body, headers = {} } = {}) {
+    const url = format({
+      host: host || this.baseUrl,
+      pathname,
+      query,
+    })
+
+    if (!method) {
+      method = 'GET'
+    }
+
+    if (headers['Content-Type'] === undefined) {
+      headers['Content-Type'] = 'application/json'
+    }
+
+    if (headers.Authorization === undefined) {
+      headers.Authorization = `Basic ${Buffer.from(`${this.email}:${this.token}`).toString('base64')}`
+    }
+
+    // strong check for undefined
+    // cause body variable can be 'false' boolean value
+    if (body && headers['Content-Type'] === 'application/json') {
+      body = JSON.stringify(body)
+    }
+
+    const state = {
+      req: {
+        method,
+        headers,
+        body,
+        url,
+      },
+    }
+
+    try {
+      await client(state, `${serviceName}:${apiMethodName}`)
+    } catch (error) {
+      const fields = {
+        originError: error,
+        source: 'jira',
+      }
+
+      delete state.req.headers
+
+      throw Object.assign(
+        new Error('Jira API error'),
+        state,
+        fields,
+        { jiraError: state.res.body.errors })
+    }
+
+    return state.res.body
+  }
+}
+
+module.exports = Jira

.github/actions/gajira-create/common/net/client.js

@@ -0,0 +1,35 @@
+const fetch = require('node-fetch')
+// const moment = require('moment')
+
+module.exports = serviceName => async (state, apiMethod = 'unknown') => {
+  // const startTime = moment.now()
+
+  const response = await fetch(state.req.url, state.req)
+
+  state.res = {
+    headers: response.headers.raw(),
+    status: response.status,
+  }
+
+  // const totalTime = moment.now() - startTime
+  // const tags = {
+  //   api_method: apiMethod,
+  //   method: state.req.method || 'GET',
+  //   response_code: response.status,
+  //   service: serviceName,
+  // }
+
+  state.res.body = await response.text()
+
+  const isJSON = (response.headers.get('content-type') || '').includes('application/json')
+
+  if (isJSON && state.res.body) {
+    state.res.body = JSON.parse(state.res.body)
+  }
+
+  if (!response.ok) {
+    throw new Error(response.statusText)
+  }
+
+  return state
+}

.github/actions/gajira-create/index.js

@@ -0,0 +1,52 @@
+const fs = require('fs')
+const core = require('@actions/core')
+
+const Action = require('./action')
+
+// eslint-disable-next-line import/no-dynamic-require
+const githubEvent = require(process.env.GITHUB_EVENT_PATH)
+const config = {
+  baseUrl: process.env.JIRA_BASE_URL,
+  token: process.env.JIRA_API_TOKEN,
+  email: process.env.JIRA_USER_EMAIL
+}
+
+async function exec () {
+  try {
+    const args = {
+        project: process.env.INPUT_PROJECT,
+        issuetype: process.env.INPUT_TYPE,
+        summary: process.env.INPUT_SUMMARY,
+        description: process.env.INPUT_DESCRIPTION,
+        area: process.env.INPUT_AREA,
+        assignee: process.env.INPUT_ASSIGNEE
+    }
+
+    console.log("ARGS")
+    console.log(JSON.stringify(args, null, 4))
+
+    const result = await new Action({
+      githubEvent,
+      argv: args,
+      config,
+    }).execute()
+
+    if (result) {
+      // result.issue is the issue key
+      console.log(`Created issue: ${result.issue}`)
+
+      // Expose created issue's key as an output
+      core.setOutput("issue", result.issue)
+
+      return true
+    }
+
+    console.log('Failed to create issue.')
+    process.exit(78)
+  } catch (error) {
+    console.error(error)
+    process.exit(1)
+  }
+}
+
+exec()