FilesExpand file tree

main

/

find-past-built-pr.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

179 lines (157 loc) · 5.93 KB

main

/

find-past-built-pr.ts

Copy path

Top

File metadata and controls

• Code
• Blame

179 lines (157 loc) · 5.93 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

import type { Octokit } from '@octokit/rest'

import github from './github'

import { getActionContext } from './action-context'

import { octoSecondaryRatelimitRetry } from './secondary-ratelimit-retry'

// This marker dedupes production comments even when another account posted them.

export const GONE_TO_PRODUCTION_MARKER = '<!-- GONE_TO_PRODUCTION -->'

// The merge queue can batch multiple PRs into a single deploy. Walk back from

// the deployed HEAD commit along first parents only to find every PR in the

// batch, because repo-sync merges bring in github/docs history whose PR numbers

// belong to the public repo. The deployed SHA bounds the search, so it cannot

// include a later batch. The SHA comes from the deploy that triggered this run,

// because one /_build read can return a newer deploy that is still rolling out.

// Manual runs have no deploy SHA and fall back to /_build.

//

// Default to the merge queue's max batch size. Overshooting into an already

// notified batch is harmless because marker dedupe skips existing comments.

const BATCH_MAX_COMMITS = parseInt(process.env.DEPLOY_BATCH_MAX_COMMITS || '5', 10)

export const COMMENT_BODY = `${GONE_TO_PRODUCTION_MARKER}

🚀 **This pull request has gone into production!**

This pull request's merge commit is included in the latest production deployment of https://docs.github.com/_build.

If you don't see updates when expected, try adding a random query string to the URL like \`?bla=1234\` and see if that helps.

If that shows the expected content, it would indicate that the CDN is "overly caching" the page still. It will eventually update, but it can take a while.

`

// GitHub appends the merged PR number to squash-merge commit titles. Grab the last one.

export function extractPrNumber(commitMessage: string): number | null {

const title = commitMessage.split('\n')[0]

const matches = [...title.matchAll(/\(#(\d+)\)/g)]

if (matches.length === 0) {

return null

}

const last = matches[matches.length - 1]

return parseInt(last[1], 10)

}

export async function findBatchPrNumbers(

octokit: Octokit,

owner: string,

repo: string,

sha: string,

maxCommits: number = BATCH_MAX_COMMITS,

): Promise<number[]> {

const numbers: number[] = []

let current: string | undefined = sha

for (let i = 0; i < maxCommits && current; i++) {

const ref: string = current

// listCommits follows every parent, so fetch one commit at a time and step to parents[0].

const { data: commits } = await octoSecondaryRatelimitRetry(() =>

octokit.rest.repos.listCommits({ owner, repo, sha: ref, per_page: 1 }),

)

const commit = commits[0]

if (!commit) {

break

}

const number = extractPrNumber(commit.commit.message)

if (number !== null && !numbers.includes(number)) {

numbers.push(number)

}

current = commit.parents[0]?.sha

}

return numbers

}

export type CommentResult = 'created' | 'exists' | 'locked'

// Posts the production comment on unlocked PRs unless the marker already exists

// under any author. Idempotent across reruns.

export async function ensureProductionComment(

octokit: Octokit,

owner: string,

repo: string,

prNumber: number,

): Promise<CommentResult> {

const { data: issue } = await octoSecondaryRatelimitRetry(() =>

octokit.rest.issues.get({ owner, repo, issue_number: prNumber }),

)

if (issue.locked) {

console.log(`Skipping locked PR #${prNumber}`)

return 'locked'

}

const comments = await octoSecondaryRatelimitRetry(() =>

octokit.paginate(octokit.rest.issues.listComments, {

owner,

repo,

issue_number: prNumber,

per_page: 100,

}),

)

if (comments.some((comment) => comment.body?.includes(GONE_TO_PRODUCTION_MARKER))) {

console.log(`PR #${prNumber} already has the production comment; skipping`)

return 'exists'

}

const { data: created } = await octoSecondaryRatelimitRetry(() =>

octokit.rest.issues.createComment({

owner,

repo,

issue_number: prNumber,

body: COMMENT_BODY,

}),

)

console.log(`Commented on PR #${prNumber}: ${created.html_url}`)

return 'created'

}

// Comments on each PR independently so one failure doesn't drop the rest of the

// batch. Collects failures and throws at the end so the workflow's failure

// alerting still fires.

export async function commentOnDeployBatch(

octokit: Octokit,

owner: string,

repo: string,

prNumbers: number[],

): Promise<void> {

const errors: Error[] = []

for (const prNumber of prNumbers) {

try {

await ensureProductionComment(octokit, owner, repo, prNumber)

} catch (error) {

console.error(`Failed to comment on PR #${prNumber}:`, error)

errors.push(error instanceof Error ? error : new Error(String(error)))

}

}

if (errors.length > 0) {

throw new Error(`Failed to comment on ${errors.length} PR(s) in the deploy batch`)

}

}

export async function resolveDeploySha(

envSha: string | undefined,

fallback: () => Promise<string>,

): Promise<string> {

if (envSha && /^[a-f0-9]{40}$/.test(envSha)) {

return envSha

}

return fallback()

}

async function main() {

const sha = await resolveDeploySha(process.env.DEPLOY_SHA, getBuiltSHA)

console.log({ sha })

const { owner, repo } = getActionContext()

const octokit = github()

const prNumbers = await findBatchPrNumbers(octokit, owner, repo, sha)

console.log(`Found ${prNumbers.length} PR(s) in the deploy batch:`, prNumbers)

await commentOnDeployBatch(octokit, owner, repo, prNumbers)

}

async function getBuiltSHA() {

const r = await fetch('https://docs.github.com/_build')

if (!r.ok) {

throw new Error(`HTTP ${r.status}: ${r.statusText}`)

}

const body = await r.text()

const sha = body.trim()

if (!/[a-f0-9]{40}/.test(sha)) {

throw new Error(`Response body does not look like a SHA ('${body.slice(0, 100)}'...)`)

}

return sha

}

const isEntryPoint =

import.meta.url === `file://${process.argv[1]}` ||

process.argv[1]?.endsWith('find-past-built-pr.ts')

if (isEntryPoint) {

main()

}