xvm.mit.edu Git - invirt/packages/invirt-dev.git/blob

1 #!/usr/bin/env python

2 """

3 A script for reporting the results of an invirtibuild. Supports any

4 combination of the following reporting mechanisms.

5

6 Note that all strings are interpolated with a dictionary containing

7 the following keys:

8

9 build_id, commit, failed_stage, inserted_at, package,

10 pocket, principal, result, short_commit, traceback, version

11

12 == zephyr ==

13

14 To configure zephyr, add something like the following to your invirt config:

15

16 build:

17 hooks:

18 post_build:

19 zephyr: &post_build_zephyr

20 class: myclass [required]

21 instance: myinstance [optional]

22 zsig: myzsig [optional]

23 failed_build:

24 zephyr: *post_build_zephyr

25 ...

26

27 == mail ==

28

29 To configure email notifications, add something like the following to your invirt config:

30

31 build:

32 hooks:

33 post_build:

34 mail: &post_build_mail

35 to: myemail@example.com [required]

36 from: myemail@example.com [required]

37 subject: My Subject [optional]

38 failed_build:

39 mail: *post_build_mail

40 ...

41

42 The script chooses which configuration option to use based off the

43 name it is called with. This name also determines which command-line

44 arguments the script takes, as well as how they are formatted. When

45 called as:

46

47 post-build: uses post_build option

48 failed-build: uses failed_build option

49 post-submit: uses post_submit option

50 failed-submit: uses failed_submit option

51 post-add-repo: uses post_add_repo option

52 """

53

54 import optparse

55 import os

56 import re

57 import sys

58 import textwrap

59

60 from email.mime import text

61

62 from invirt import common, database, builder

63 from invirt.config import structs as config

64

65 def build_completion_msg(succeeded, values, verbose=True, success=lambda x: x, failure=lambda x: x,

66 escape=lambda x: x):

67 """Format a message reporting the results of a build"""

68 values = dict(values)

69 if not verbose and values['traceback'] is not None:

70 split = values['traceback'].split('\n')

71 # Here, have a hackish heuristic

72 truncated = '(empty)'

73 for i in xrange(2, len(split)):

74 truncated = textwrap.fill('\n'.join(split[-i:]))

75 if len(truncated) >= 10:

76 break

77 values['traceback'] = truncated

78

79 for key in ['package', 'version', 'pocket', 'principal', 'inserted_at', 'short_commit']:

80 values[key] = escape(values[key])

81

82 if succeeded:

83 values['result'] = success(values['result'])

84 msg = """Build of %(package)s %(version)s in %(pocket)s %(result)s.

85 Job submitted by %(principal)s at %(inserted_at)s.

86 Branch %(pocket)s has been advanced to %(short_commit)s.""" % values

87 else:

88 values['result'] = failure(values['result'])

89 msg = """Build of %(package)s version %(version)s in %(pocket)s %(result)s while %(failed_stage)s.

90 Job submitted by %(principal)s at %(inserted_at)s.

91 Error: %(traceback)s""" % values

92 return msg

93

94 def submit_completion_msg(succeeded, values, verbose=True, success=lambda x: x, failure=lambda x: x,

95 escape=lambda x: x):

96 values = dict(values)

97 if succeeded:

98 values['result'] = success(values['result'])

99 values['_extra'] = ''

100 else:

101 values['result'] = failure(values['result'])

102 values['_extra'] = '\nError: %s' % escape(sys.stdin.read())

103 for key in ['commit', 'pocket', 'principal']:

104 values[key] = escape(values[key])

105 msg = """Submission of %(commit)s to be built in %(pocket)s %(result)s.

106 Build submitted by %(principal)s.%(_extra)s""" % values

107 return msg

108

109 def repo_creation_msg(succeeded, values, verbose=True, success=lambda x: x, failure=lambda x: x,

110 escape=lambda x: x):

111 values = dict(values)

112 assert succeeded

113 for key in ['category', 'name', 'principal']:

114 values[key] = escape(values[key])

115 msg = '%(principal)s just created a new repository, %(category)s/%(name)s.git' % values

116 return msg

117

118 def prebuild_msg(succeeded, values, verbose=True, success=lambda x: x, failure=lambda x: x,

119 escape=lambda x: x):

120 for key in ['build_id', 'pocket', 'package', 'commit', 'principal', 'version', 'inserted_at']:

121 values[key] = escape(values[key])

122 msg = """Build started: %(package)s %(version)s in %(pocket)s.

123 Base commit %(commit)s .

124 Job submitted by %(principal)s at %(inserted_at)s.""" % values

125 return msg

126

127 # Names of hooks

128 POST_BUILD = 'post-build'

129 FAILED_BUILD = 'failed-build'

130 POST_SUBMIT = 'post-submit'

131 FAILED_SUBMIT = 'failed-submit'

132 POST_ADD_REPO = 'post-add-repo'

133 PRE_BUILD = 'pre-build'

134

135 # Types of communication

136

137 ZEPHYR = 'zephyr'

138 MAIL = 'mail'

139

140 message_generators = {

141 ZEPHYR : { POST_BUILD : build_completion_msg,

142 FAILED_BUILD : build_completion_msg,

143 POST_SUBMIT : submit_completion_msg,

144 FAILED_SUBMIT : submit_completion_msg,

145 POST_ADD_REPO : repo_creation_msg,

146 PRE_BUILD : prebuild_msg },

147 MAIL : { POST_BUILD : build_completion_msg,

148 FAILED_BUILD : build_completion_msg,

149 POST_SUBMIT : submit_completion_msg,

150 FAILED_SUBMIT : submit_completion_msg,

151 POST_ADD_REPO : repo_creation_msg,

152 PRE_BUILD : prebuild_msg }

153 }

154

155 def zephyr_escape(m):

156 m = str(m)

157 m = re.sub('@', '@@', m)

158 m = re.sub('}', '@(})', m)

159 return m

160

161 def zephyr_success(m):

162 return '}@{@color(green)%s}@{' % zephyr_escape(m)

163

164 def zephyr_failure(m):

165 return '}@{@color(red)%s}@{' % zephyr_escape(m)

166

167 def main():

168 parser = optparse.OptionParser('Usage: %prog [options] [arguments]')

169 opts, args = parser.parse_args()

170 prog = os.path.basename(sys.argv[0])

171

172 try:

173 if prog == POST_BUILD:

174 hook_config = config.build.hooks.post_build

175 elif prog == FAILED_BUILD:

176 hook_config = config.build.hooks.failed_build

177 elif prog == POST_SUBMIT:

178 hook_config = config.build.hooks.post_submit

179 elif prog == FAILED_SUBMIT:

180 hook_config = config.build.hooks.failed_submit

181 elif prog == POST_ADD_REPO:

182 hook_config = config.build.hooks.post_add_repo

183 elif prog == PRE_BUILD:

184 hook_config = config.build.hooks.pre_build

185 else:

186 parser.error('hook script invoked with unrecognized name %s' % prog)

187 return 2

188 except common.InvirtConfigError:

189 print >>sys.stderr, 'No hook configuration found for %s.' % prog

190 return 1

191

192 if prog in [POST_BUILD, FAILED_BUILD, PRE_BUILD]:

193 if len(args) != 1:

194 parser.set_usage('Usage: %prog [options] build_id')

195 parser.print_help()

196 return 1

197 database.connect()

198 build = database.Build.query().get(args[0])

199 short_commit = builder.canonicalize_commit(build.package, build.commit, shorten=True)

200 values = { 'build_id' : build.build_id,

201 'commit' : build.commit,

202 'failed_stage' : build.failed_stage,

203 'inserted_at' : build.inserted_at,

204 'package' : build.package,

205 'pocket' : build.pocket,

206 'principal' : build.principal,

207 'short_commit' : short_commit,

208 'traceback' : build.traceback,

209 'version' : build.version,

210 'default_instance' : 'b%(build_id)s',

211 'default_subject' : 'Build %(build_id)d %(result)s: %(package)s %(version)s in %(pocket)s'}

212 if prog == PRE_BUILD:

213 succeeded = True

214 elif build.succeeded:

215 assert prog == POST_BUILD

216 values['result'] = 'succeeded'

217 succeeded = True

218 else:

219 assert prog == FAILED_BUILD

220 values['result'] = 'failed'

221 succeeded = False

222 elif prog in [POST_SUBMIT, FAILED_SUBMIT]:

223 if len(args) != 4:

224 parser.set_usage('Usage: %prog [options] pocket package commit principal')

225 parser.print_help()

226 return 2

227 values = { 'pocket' : args[0],

228 'package' : args[1],

229 'commit' : args[2],

230 'principal' : args[3],

231 'default_instance' : 'submission',

232 'default_subject' : 'Submission %(result)s: %(package)s %(version)s in %(pocket)s'}

233 if prog == POST_SUBMIT:

234 values['result'] = 'succeeded'

235 succeeded = True

236 else:

237 values['result'] = 'failed'

238 succeeded = False

239 elif prog in [POST_ADD_REPO]:

240 if len(args) != 3:

241 parser.set_usage('Usage: %prog [options] category name principal')

242 parser.print_help()

243 return 3

244 values = { 'category' : args[0],

245 'name' : args[1],

246 'principal' : args[2],

247 'default_instance' : 'new-repo',

248 'default_subject' : 'New repository %(category)s/%(name)s'}

249 succeeded = True

250 else:

251 raise AssertionError('Impossible state')

252

253 try:

254 zephyr_config = hook_config.zephyr

255 klass = zephyr_config['class'] % values

256 except common.InvirtConfigError:

257 print >>sys.stderr, 'No zephyr configuration specified for %s.' % prog

258 else:

259 make_msg = message_generators[ZEPHYR][prog]

260 msg = '@{%s}' % make_msg(succeeded, values, verbose=False,

261 success=zephyr_success, failure=zephyr_failure,

262 escape=zephyr_escape)

263 instance = zephyr_config.get('instance', values['default_instance']) % values

264 zsig = zephyr_config.get('zsig', 'XVM Buildbot') % values

265 common.captureOutput(['zwrite', '-c', klass, '-i', instance, '-s',

266 zsig, '-d', '-m', msg],

267 stdout=None, stderr=None)

268

269 try:

270 mail_config = hook_config.mail

271 to = mail_config.to % values

272 sender = mail_config['from'] % values

273 except common.InvirtConfigError:

274 print >>sys.stderr, 'No email configuration specified for %s.' % prog

275 else:

276 make_msg = message_generators[MAIL][prog]

277 msg = make_msg(succeeded, values)

278 email = text.MIMEText(msg)

279 email['To'] = to % values

280 email['From'] = sender % values

281 email['Subject'] = mail_config.get('subject', values['default_subject']) % values

282 common.captureOutput(['sendmail', '-t'], email.as_string(),

283 stdout=None, stderr=None)

284

285 if __name__ == '__main__':

286 sys.exit(main())