cypress/scripts/wait-on-circle-jobs.js at develop · kshastri/cypress · GitHub - github.com

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
/* eslint-disable no-console */

const _ = require('lodash')
const minimist = require('minimist')
const Promise = require('bluebird')
const retry = require('bluebird-retry')
const got = require('got')
// always print the debug logs
const debug = require('debug')('*')

const { seconds, minutes } = require('./utils')

// we expect CircleCI to set the current polling job name
const jobName = process.env.CIRCLE_JOB || 'wait-on-circle-jobs'

const workflowId = process.env.CIRCLE_WORKFLOW_ID

const branchesToAlwaysFinalize = ['develop', '10.0-release']

const requireAllJobsToPass = !branchesToAlwaysFinalize.includes(process.env.CIRCLE_BRANCH)

const getAuth = () => `${process.env.CIRCLE_TOKEN}:`

const verifyCI = () => {
  if (!process.env.CIRCLE_TOKEN) {
    console.error('Cannot find CIRCLE_TOKEN')
    process.exit(1)
  }

  if (!process.env.CIRCLE_WORKFLOW_ID) {
    console.error('Cannot find CIRCLE_WORKFLOW_ID')
    process.exit(1)
  }
}

/**
 * Job status
 *  - blocked (has not run yet)
 *  - running (currently running)
 *  - failed | success
*/
const getJobStatus = async (workflowId) => {
  const auth = getAuth()
  // typo at https://circleci.com/docs/2.0/api-intro/
  // to retrieve all jobs, the url is "/workflow/:id/job"
  const url = `https://${auth}@circleci.com/api/v2/workflow/${workflowId}/job`
  const response = await got(url).json()

  // returns something like
  // {
  //   next_page_token: null,
  //   items: [
  //     {
  //       dependencies: [],
  //       job_number: 400959,
  //       id: '7021bcc7-90c1-47d9-bf99-c0372a4f8f49',
  //       started_at: '2020-07-20T19:45:46Z',
  //       name: 'build',
  //       project_slug: 'gh/cypress-io/cypress',
  //       status: 'success',
  //       type: 'build',
  //       stopped_at: '2020-07-20T19:50:07Z'
  //     }
  //   ]
  // }
  return response
}

const waitForAllJobs = async (jobNames, workflowId) => {
  let response

  try {
    response = await getJobStatus(workflowId)
  } catch (e) {
    console.error(e)
    process.exit(1)
  }

  // if a job is pending, its status will be "blocked"
  const blockedJobs = _.filter(response.items, { status: 'blocked' })
  const failedJobs = _.filter(response.items, { status: 'failed' })

  const runningJobs = _.filter(response.items, { status: 'running' })

  const blockedJobNames = _.map(blockedJobs, 'name')
  const runningJobNames = _.map(runningJobs, 'name')
  const failedJobNames = _.map(failedJobs, 'name')

  if (requireAllJobsToPass && _.intersection(jobNames, failedJobNames).length) {
    console.error('At least one failing job has prevented percy-finalize from running', failedJobs)
    process.exit(1)
  }

  debug('failed jobs %o', _.map(failedJobs, 'name'))
  debug('blocked jobs %o', blockedJobNames)
  debug('running jobs %o', runningJobNames)

  if (!runningJobs.length || (runningJobs.length === 1 && runningJobs[0].name === jobName)) {
    // there are no more jobs to run, or this is the last running job
    console.log('all jobs are done, finishing this job')

    return Promise.resolve()
  }

  const futureOrRunning = _.union(blockedJobs, runningJobNames)
  const jobsToWaitFor = _.intersection(jobNames, futureOrRunning)

  // logging something every time this runs will avoid CI timing out if there is no activity for 10 mins.
  console.log(`waiting for jobs, jobs outstanding: ${response.items.length}`)

  debug('jobs to wait for %o', jobsToWaitFor)

  if (!jobsToWaitFor.length) {
    console.log('No more jobs to wait for!')

    return Promise.resolve()
  }

  return Promise.reject(new Error('Jobs have not finished'))
}

const main = () => {
  verifyCI()

  const args = minimist(process.argv.slice(2), { boolean: false })

  const jobNames = _
  .chain(args['job-names'])
  .split(',')
  .without('true')
  .map(_.trim)
  .compact()
  .value()

  if (!jobNames.length) {
    console.error('Missing argument: --job-names')
    console.error('You must pass a comma separated list of Circle CI job names to wait for.')
    process.exit(1)
  }

  debug('received circle jobs: %o', jobNames)

  // https://github.com/demmer/bluebird-retry
  retry(waitForAllJobs.bind(null, jobNames, workflowId), {
    timeout: minutes(30), // max time for this job
    interval: seconds(30), // poll intervals
    max_interval: seconds(30),
  }).then(() => {
    console.log('all done')
  }, (err) => {
    console.error(err)
    process.exit(1)
  })
}

// execute main function if called from command line
if (require.main === module) {
  main()
}