commit 23b82b322868e32e3b0fcd60c08e03bf0a0ac505 · pyrox.dev/nixpkgs

+10 -12

ci/github-script/commits.js

···

       1
       1
        
       module.exports = async ({ github, context, core, dry }) => {

     

       2
       2
        
         const { execFileSync } = require('node:child_process')

     

       3
       3
       -
         const { readFile } = require('node:fs/promises')

     

       4
       4
       -
         const { join } = require('node:path')

     

       5
       3
        
         const { classify } = require('../supportedBranches.js')

     

       6
       4
        
         const withRateLimit = require('./withRateLimit.js')

     

       7
       5
        
       

     
···

       18
       16
        
                 run_id: context.runId,

     

       19
       17
        
                 per_page: 100,

     

       20
       18
        
               })

     

       21
       21
       -
             ).find(({ name }) => name == 'Check / cherry-pick').html_url +

     

       19
       19
       +
             ).find(({ name }) => name === 'Check / cherry-pick').html_url +

     

       22
       20
        
               '?pr=' +

     

       23
       21
        
               pull_number

     

       24
       22
        
       

     
···

       178
       176
        
       

     

       179
       177
        
           // Only create step summary below in case of warnings or errors.

     

       180
       178
        
           // Also clean up older reviews, when all checks are good now.

     

       181
       181
       -
           if (results.every(({ severity }) => severity == 'info')) {

     

       179
       179
       +
           if (results.every(({ severity }) => severity === 'info')) {

     

       182
       180
        
             if (!dry) {

     

       183
       181
        
               await Promise.all(

     

       184
       182
        
                 (

     
···

       187
       185
        
                     pull_number,

     

       188
       186
        
                   })

     

       189
       187
        
                 )

     

       190
       190
       -
                   .filter((review) => review.user.login == 'github-actions[bot]')

     

       188
       188
       +
                   .filter((review) => review.user.login === 'github-actions[bot]')

     

       191
       189
        
                   .map(async (review) => {

     

       192
       192
       -
                     if (review.state == 'CHANGES_REQUESTED') {

     

       190
       190
       +
                     if (review.state === 'CHANGES_REQUESTED') {

     

       193
       191
        
                       await github.rest.pulls.dismissReview({

     

       194
       192
        
                         ...context.repo,

     

       195
       193
        
                         pull_number,

     
···

       215
       213
        
       

     

       216
       214
        
           // In the case of "error" severity, we also fail the job.

     

       217
       215
        
           // Those should be considered blocking and not be dismissable via review.

     

       218
       218
       -
           if (results.some(({ severity }) => severity == 'error'))

     

       216
       216
       +
           if (results.some(({ severity }) => severity === 'error'))

     

       219
       217
        
             process.exitCode = 1

     

       220
       218
        
       

     

       221
       219
        
           core.summary.addRaw(

     
···

       272
       270
        
           )

     

       273
       271
        
       

     

       274
       272
        
           results.forEach(({ severity, message, diff }) => {

     

       275
       275
       -
             if (severity == 'info') return

     

       273
       273
       +
             if (severity === 'info') return

     

       276
       274
        
       

     

       277
       275
        
             // The docs for markdown alerts only show examples with markdown blockquote syntax, like this:

     

       278
       276
        
             //   > [!WARNING]

     
···

       336
       334
        
             })

     

       337
       335
        
           ).find(

     

       338
       336
        
             (review) =>

     

       339
       339
       -
               review.user.login == 'github-actions[bot]' &&

     

       337
       337
       +
               review.user.login === 'github-actions[bot]' &&

     

       340
       338
        
               // If a review is still pending, we can just update this instead

     

       341
       339
        
               // of posting a new one.

     

       342
       342
       -
               (review.state == 'CHANGES_REQUESTED' ||

     

       340
       340
       +
               (review.state === 'CHANGES_REQUESTED' ||

     

       343
       341
        
                 // No need to post a new review, if an older one with the exact

     

       344
       342
        
                 // same content had already been dismissed.

     

       345
       345
       -
                 review.body == body),

     

       343
       343
       +
                 review.body === body),

     

       346
       344
        
           )

     

       347
       345
        
       

     

       348
       346
        
           if (dry) {

     

       349
       347
        
             if (pendingReview)

     

       350
       350
       -
               core.info('pending review found: ' + pendingReview.html_url)

     

       348
       348
       +
               core.info(`pending review found: ${pendingReview.html_url}`)

     

       351
       349
        
             else core.info('no pending review found')

     

       352
       350
        
           } else {

     

       353
       351
        
             // Either of those two requests could fail for very long comments. This can only happen

+15 -16

ci/github-script/labels.js

···

       27
       27
        
       

     

       28
       28
        
           const approvals = new Set(

     

       29
       29
        
             reviews

     

       30
       30
       -
               .filter((review) => review.state == 'APPROVED')

     

       30
       30
       +
               .filter((review) => review.state === 'APPROVED')

     

       31
       31
        
               .map((review) => review.user?.id),

     

       32
       32
        
           )

     

       33
       33
        
       

     
···

       37
       37
        
           // This is intentionally less than the time that Eval takes, so that the label job

     

       38
       38
        
           // running after Eval can indeed label the PR as conflicted if that is the case.

     

       39
       39
        
           const merge_commit_sha_valid =

     

       40
       40
       -
             new Date() - new Date(pull_request.created_at) > 3 * 60 * 1000

     

       40
       40
       +
             Date.now() - new Date(pull_request.created_at) > 3 * 60 * 1000

     

       41
       41
        
       

     

       42
       42
        
           const prLabels = {

     

       43
       43
        
             // We intentionally don't use the mergeable or mergeable_state attributes.

     
···

       53
       53
        
             // The second pass will then read the result from the first pass and set the label.

     

       54
       54
        
             '2.status: merge conflict':

     

       55
       55
        
               merge_commit_sha_valid && !pull_request.merge_commit_sha,

     

       56
       56
       -
             '12.approvals: 1': approvals.size == 1,

     

       57
       57
       -
             '12.approvals: 2': approvals.size == 2,

     

       56
       56
       +
             '12.approvals: 1': approvals.size === 1,

     

       57
       57
       +
             '12.approvals: 2': approvals.size === 2,

     

       58
       58
        
             '12.approvals: 3+': approvals.size >= 3,

     

       59
       59
        
             '12.first-time contribution': [

     

       60
       60
        
               'NONE',

     
···

       104
       104
        
               // existing reviews, too.

     

       105
       105
        
               '9.needs: reviewer':

     

       106
       106
        
                 !pull_request.draft &&

     

       107
       107
       -
                 pull_request.requested_reviewers.length == 0 &&

     

       108
       108
       -
                 reviews.length == 0,

     

       107
       107
       +
                 pull_request.requested_reviewers.length === 0 &&

     

       108
       108
       +
                 reviews.length === 0,

     

       109
       109
        
             })

     

       110
       110
        
           }

     

       111
       111
        
       

     
···

       125
       125
        
           // called "comparison", yet, will skip the download.

     

       126
       126
        
           const expired =

     

       127
       127
        
             !artifact ||

     

       128
       128
       -
             new Date(artifact?.expires_at ?? 0) <

     

       129
       129
       -
               new Date(new Date().getTime() + 60 * 1000)

     

       128
       128
       +
             new Date(artifact?.expires_at ?? 0) < new Date(Date.now() + 60 * 1000)

     

       130
       129
        
           log('Artifact expires at', artifact?.expires_at ?? '<n/a>')

     

       131
       130
        
           if (!expired) {

     

       132
       131
        
             stats.artifacts++

     
···

       175
       174
        
         async function handle({ item, stats }) {

     

       176
       175
        
           try {

     

       177
       176
        
             const log = (k, v, skip) => {

     

       178
       178
       -
               core.info(`#${item.number} - ${k}: ${v}` + (skip ? ' (skipped)' : ''))

     

       177
       177
       +
               core.info(`#${item.number} - ${k}: ${v}${skip ? ' (skipped)' : ''}`)

     

       179
       178
        
               return skip

     

       180
       179
        
             }

     

       181
       180
        
       

     
···

       257
       256
        
       

     

       258
       257
        
             // No need for an API request, if all labels are the same.

     

       259
       258
        
             const hasChanges = Object.keys(after).some(

     

       260
       260
       -
               (name) => (before[name] ?? false) != after[name],

     

       259
       259
       +
               (name) => (before[name] ?? false) !== after[name],

     

       261
       260
        
             )

     

       262
       261
        
             if (log('Has changes', hasChanges, !hasChanges)) return

     

       263
       262
        
       

     
···

       298
       297
        
                 // we are not leaving anyone behind on GHA failures.

     

       299
       298
        
                 // Defaults to go back 1 hour on the first run.

     

       300
       299
        
                 new Date(

     

       301
       301
       -
                   lastRun?.created_at ?? new Date().getTime() - 1 * 60 * 60 * 1000,

     

       300
       300
       +
                   lastRun?.created_at ?? Date.now() - 1 * 60 * 60 * 1000,

     

       302
       301
        
                 ).getTime(),

     

       303
       302
        
                 // Go back max. 1 day to prevent hitting all API rate limits immediately,

     

       304
       303
        
                 // when GH API returns a wrong workflow by accident.

     

       305
       305
       -
                 new Date().getTime() - 24 * 60 * 60 * 1000,

     

       304
       304
       +
                 Date.now() - 24 * 60 * 60 * 1000,

     

       306
       305
        
               ),

     

       307
       306
        
             )

     

       308
       308
       -
             core.info('cutoff timestamp: ' + cutoff.toISOString())

     

       307
       307
       +
             core.info(`cutoff timestamp: ${cutoff.toISOString()}`)

     

       309
       308
        
       

     

       310
       309
        
             const updatedItems = await github.paginate(

     

       311
       310
        
               github.rest.search.issuesAndPullRequests,

     
···

       402
       401
        
               .concat(updatedItems, allItems.data)

     

       403
       402
        
               .filter(

     

       404
       403
        
                 (thisItem, idx, arr) =>

     

       405
       405
       -
                   idx ==

     

       406
       406
       -
                   arr.findIndex((firstItem) => firstItem.number == thisItem.number),

     

       404
       404
       +
                   idx ===

     

       405
       405
       +
                   arr.findIndex((firstItem) => firstItem.number === thisItem.number),

     

       407
       406
        
               )

     

       408
       407
        
       

     

       409
       408
        
             ;(await Promise.allSettled(items.map((item) => handle({ item, stats }))))

     

       410
       410
       -
               .filter(({ status }) => status == 'rejected')

     

       409
       409
       +
               .filter(({ status }) => status === 'rejected')

     

       411
       410
        
               .map(({ reason }) =>

     

       412
       411
        
                 core.setFailed(`${reason.message}\n${reason.cause.stack}`),

     

       413
       412
        
               )

+1 -1

ci/github-script/withRateLimit.js

···

       23
       23
        
           // Requests to a different host do not count against the rate limit.

     

       24
       24
        
           if (options.url.startsWith('https://github.com')) return request(options)

     

       25
       25
        
           // Requests to the /rate_limit endpoint do not count against the rate limit.

     

       26
       26
       -
           if (options.url == '/rate_limit') return request(options)

     

       26
       26
       +
           if (options.url === '/rate_limit') return request(options)

     

       27
       27
        
           // Search requests are in a different resource group, which allows 30 requests / minute.

     

       28
       28
        
           // We do less than a handful each run, so not implementing throttling for now.

     

       29
       29
        
           if (options.url.startsWith('/search/')) return request(options)