autobuild: Add --daemon option.
[sfrench/samba-autobuild/.git] / script / autobuild.py
1 #!/usr/bin/env python
2 # run tests on all Samba subprojects and push to a git tree on success
3 # Copyright Andrew Tridgell 2010
4 # released under GNU GPL v3 or later
5
6 from subprocess import Popen, PIPE
7 import os, signal, tarfile, sys, time
8 from optparse import OptionParser
9 import smtplib
10 from email.mime.text import MIMEText
11
12 samba_master = os.getenv('SAMBA_MASTER', 'git://git.samba.org/samba.git')
13 samba_master_ssh = os.getenv('SAMBA_MASTER_SSH', 'git+ssh://git.samba.org/data/git/samba.git')
14
15 cleanup_list = []
16
17 os.putenv('CC', "ccache gcc")
18
19 tasks = {
20     "source3" : [ "./autogen.sh",
21                   "./configure.developer ${PREFIX}",
22                   "make basics",
23                   "make -j 4 everything", # don't use too many processes
24                   "make install",
25                   "TDB_NO_FSYNC=1 make test FAIL_IMMEDIATELY=1" ],
26
27     "source4" : [ "./configure.developer ${PREFIX}",
28                   "make -j",
29                   "make install",
30                   "TDB_NO_FSYNC=1 make test FAIL_IMMEDIATELY=1" ],
31
32     "source4/lib/ldb" : [ "./configure --enable-developer -C ${PREFIX}",
33                           "make -j",
34                           "make install",
35                           "make test" ],
36
37     "lib/tdb" : [ "./autogen-waf.sh",
38                   "./configure --enable-developer -C ${PREFIX}",
39                   "make -j",
40                   "make install",
41                   "make test" ],
42
43     "lib/talloc" : [ "./autogen-waf.sh",
44                      "./configure --enable-developer -C ${PREFIX}",
45                      "make -j",
46                      "make install",
47                      "make test" ],
48
49     "lib/replace" : [ "./autogen-waf.sh",
50                       "./configure --enable-developer -C ${PREFIX}",
51                       "make -j",
52                       "make install",
53                       "make test" ],
54
55     "lib/tevent" : [ "./configure --enable-developer -C ${PREFIX}",
56                      "make -j",
57                      "make install",
58                      "make test" ],
59 }
60
61 retry_task = [ '''set -e
62                 git remote add -t master master %s
63                 git fetch master
64                 while :; do
65                   sleep 60
66                   git describe master/master > old_master.desc
67                   git fetch master
68                   git describe master/master > master.desc
69                   diff old_master.desc master.desc
70                 done
71                ''' % samba_master]
72
73 def run_cmd(cmd, dir=".", show=None, output=False, checkfail=True):
74     cwd = os.getcwd()
75     os.chdir(dir)
76     if show is None:
77         show = options.verbose
78     if show:
79         print("Running: '%s' in '%s'" % (cmd, dir))
80     if output:
81         ret = Popen([cmd], shell=True, stdout=PIPE).communicate()[0]
82         os.chdir(cwd)
83         return ret
84     ret = os.system(cmd)
85     os.chdir(cwd)
86     if checkfail and ret != 0:
87         raise Exception("FAILED %s: %d" % (cmd, ret))
88     return ret
89
90 class builder:
91     '''handle build of one directory'''
92     def __init__(self, name, sequence):
93         self.name = name
94
95         if name in ['pass', 'fail', 'retry']:
96             self.dir = "."
97         else:
98             self.dir = self.name
99
100         self.tag = self.name.replace('/', '_')
101         self.sequence = sequence
102         self.next = 0
103         self.stdout_path = "%s/%s.stdout" % (gitroot, self.tag)
104         self.stderr_path = "%s/%s.stderr" % (gitroot, self.tag)
105         if options.verbose:
106             print("stdout for %s in %s" % (self.name, self.stdout_path))
107             print("stderr for %s in %s" % (self.name, self.stderr_path))
108         run_cmd("rm -f %s %s" % (self.stdout_path, self.stderr_path))
109         self.stdout = open(self.stdout_path, 'w')
110         self.stderr = open(self.stderr_path, 'w')
111         self.stdin  = open("/dev/null", 'r')
112         self.sdir = "%s/%s" % (testbase, self.tag)
113         self.prefix = "%s/prefix/%s" % (testbase, self.tag)
114         run_cmd("rm -rf %s" % self.sdir)
115         cleanup_list.append(self.sdir)
116         cleanup_list.append(self.prefix)
117         os.makedirs(self.sdir)
118         run_cmd("rm -rf %s" % self.sdir)
119         run_cmd("git clone --shared %s %s" % (gitroot, self.sdir))
120         self.start_next()
121
122     def start_next(self):
123         if self.next == len(self.sequence):
124             print '%s: Completed OK' % self.name
125             self.done = True
126             return
127         self.cmd = self.sequence[self.next].replace("${PREFIX}", "--prefix=%s" % self.prefix)
128         print '%s: Running %s' % (self.name, self.cmd)
129         cwd = os.getcwd()
130         os.chdir("%s/%s" % (self.sdir, self.dir))
131         self.proc = Popen(self.cmd, shell=True,
132                           stdout=self.stdout, stderr=self.stderr, stdin=self.stdin)
133         os.chdir(cwd)
134         self.next += 1
135
136
137 class buildlist:
138     '''handle build of multiple directories'''
139     def __init__(self, tasklist, tasknames):
140         global tasks
141         self.tlist = []
142         self.tail_proc = None
143         self.retry = None
144         if tasknames == ['pass']:
145             tasks = { 'pass' : [ '/bin/true' ]}
146         if tasknames == ['fail']:
147             tasks = { 'fail' : [ '/bin/false' ]}
148         if tasknames == []:
149             tasknames = tasklist
150         for n in tasknames:
151             b = builder(n, tasks[n])
152             self.tlist.append(b)
153         if options.retry:
154             self.retry = builder('retry', retry_task)
155             self.need_retry = False
156
157     def kill_kids(self):
158         if self.tail_proc is not None:
159             self.tail_proc.terminate()
160             self.tail_proc.wait()
161             self.tail_proc = None
162         if self.retry is not None:
163             self.retry.proc.terminate()
164             self.retry.proc.wait()
165             self.retry = None
166         for b in self.tlist:
167             if b.proc is not None:
168                 run_cmd("killbysubdir %s > /dev/null 2>&1" % b.sdir, checkfail=False)
169                 b.proc.terminate()
170                 b.proc.wait()
171                 b.proc = None
172
173     def wait_one(self):
174         while True:
175             none_running = True
176             for b in self.tlist:
177                 if b.proc is None:
178                     continue
179                 none_running = False
180                 b.status = b.proc.poll()
181                 if b.status is None:
182                     continue
183                 b.proc = None
184                 return b
185             if options.retry:
186                 ret = self.retry.proc.poll()
187                 if ret is not None:
188                     self.need_retry = True
189                     self.retry = None
190                     return None
191             if none_running:
192                 return None
193             time.sleep(0.1)
194
195     def run(self):
196         while True:
197             b = self.wait_one()
198             if options.retry and self.need_retry:
199                 self.kill_kids()
200                 print("retry needed")
201                 return (0, "retry")
202             if b is None:
203                 break
204             if os.WIFSIGNALED(b.status) or os.WEXITSTATUS(b.status) != 0:
205                 self.kill_kids()
206                 return (b.status, b.name, b.tag, "%s: failed '%s' with status %d" % (b.name, b.cmd, b.status))
207             b.start_next()
208         self.kill_kids()
209         return (0, None, None, "All OK")
210
211     def tarlogs(self, fname):
212         tar = tarfile.open(fname, "w:gz")
213         for b in self.tlist:
214             tar.add(b.stdout_path, arcname="%s.stdout" % b.tag)
215             tar.add(b.stderr_path, arcname="%s.stderr" % b.tag)
216         tar.close()
217
218     def remove_logs(self):
219         for b in self.tlist:
220             os.unlink(b.stdout_path)
221             os.unlink(b.stderr_path)
222
223     def start_tail(self):
224         cwd = os.getcwd()
225         cmd = "tail -f *.stdout *.stderr"
226         os.chdir(gitroot)
227         self.tail_proc = Popen(cmd, shell=True)
228         os.chdir(cwd)
229
230
231 def cleanup():
232     if options.nocleanup:
233         return
234     print("Cleaning up ....")
235     for d in cleanup_list:
236         run_cmd("rm -rf %s" % d)
237
238
239 def find_git_root():
240     '''get to the top of the git repo'''
241     p=os.getcwd()
242     while p != '/':
243         if os.path.isdir(os.path.join(p, ".git")):
244             return p
245         p = os.path.abspath(os.path.join(p, '..'))
246     return None
247
248
249 def daemonize(logfile):
250     pid = os.fork()
251     if pid == 0: # Parent
252         os.setsid()
253         pid = os.fork()
254         if pid != 0: # Actual daemon
255             os._exit(0)
256     else: # Grandparent
257         os._exit(0)
258
259     import resource      # Resource usage information.
260     maxfd = resource.getrlimit(resource.RLIMIT_NOFILE)[1]
261     if maxfd == resource.RLIM_INFINITY:
262         maxfd = 1024 # Rough guess at maximum number of open file descriptors.
263     for fd in range(0, maxfd):
264         try:
265             os.close(fd)
266         except OSError:
267             pass
268     os.open(logfile, os.O_RDWR | os.O_CREAT)
269     os.dup2(0, 1)
270     os.dup2(0, 2)
271
272
273 def rebase_tree(url):
274     print("Rebasing on %s" % url)
275     run_cmd("git remote add -t master master %s" % url, show=True, dir=test_master)
276     run_cmd("git fetch master", show=True, dir=test_master)
277     if options.fix_whitespace:
278         run_cmd("git rebase --whitespace=fix master/master", show=True, dir=test_master)
279     else:
280         run_cmd("git rebase master/master", show=True, dir=test_master)
281     diff = run_cmd("git --no-pager diff HEAD master/master", dir=test_master, output=True)
282     if diff == '':
283         print("No differences between HEAD and master/master - exiting")
284         sys.exit(0)
285
286 def push_to(url):
287     print("Pushing to %s" % url)
288     if options.mark:
289         run_cmd("EDITOR=script/commit_mark.sh git commit --amend -c HEAD", dir=test_master)
290         # the notes method doesn't work yet, as metze hasn't allowed refs/notes/* in master
291         # run_cmd("EDITOR=script/commit_mark.sh git notes edit HEAD", dir=test_master)
292     run_cmd("git remote add -t master pushto %s" % url, show=True, dir=test_master)
293     run_cmd("git push pushto +HEAD:master", show=True, dir=test_master)
294
295 def_testbase = os.getenv("AUTOBUILD_TESTBASE", "/memdisk/%s" % os.getenv('USER'))
296
297 parser = OptionParser()
298 parser.add_option("", "--tail", help="show output while running", default=False, action="store_true")
299 parser.add_option("", "--keeplogs", help="keep logs", default=False, action="store_true")
300 parser.add_option("", "--nocleanup", help="don't remove test tree", default=False, action="store_true")
301 parser.add_option("", "--testbase", help="base directory to run tests in (default %s)" % def_testbase,
302                   default=def_testbase)
303 parser.add_option("", "--passcmd", help="command to run on success", default=None)
304 parser.add_option("", "--verbose", help="show all commands as they are run",
305                   default=False, action="store_true")
306 parser.add_option("", "--rebase", help="rebase on the given tree before testing",
307                   default=None, type='str')
308 parser.add_option("", "--rebase-master", help="rebase on %s before testing" % samba_master,
309                   default=False, action='store_true')
310 parser.add_option("", "--pushto", help="push to a git url on success",
311                   default=None, type='str')
312 parser.add_option("", "--push-master", help="push to %s on success" % samba_master_ssh,
313                   default=False, action='store_true')
314 parser.add_option("", "--mark", help="add a Tested-By signoff before pushing",
315                   default=False, action="store_true")
316 parser.add_option("", "--fix-whitespace", help="fix whitespace on rebase",
317                   default=False, action="store_true")
318 parser.add_option("", "--retry", help="automatically retry if master changes",
319                   default=False, action="store_true")
320 parser.add_option("", "--email", help="send email to the given address on failure",
321                   type='str', default=None)
322 parser.add_option("", "--daemon", help="daemonize after initial setup",
323                   action="store_true")
324
325
326 def email_failure(status, failed_task, failed_tag, errstr):
327     '''send an email to options.email about the failure'''
328     user = os.getenv("USER")
329     text = '''
330 Dear Developer,
331
332 Your autobuild failed when trying to test %s with the following error:
333    %s
334
335 the autobuild has been abandoned. Please fix the error and resubmit.
336
337 You can see logs of the failed task here:
338
339   http://git.samba.org/%s/samba-autobuild/%s.stdout
340   http://git.samba.org/%s/samba-autobuild/%s.stderr
341
342 or you can get full logs of all tasks in this job here:
343
344   http://git.samba.org/%s/samba-autobuild/logs.tar.gz
345
346 ''' % (failed_task, errstr, user, failed_tag, user, failed_tag, user)
347     msg = MIMEText(text)
348     msg['Subject'] = 'autobuild failure for task %s' % failed_task
349     msg['From'] = 'autobuild@samba.org'
350     msg['To'] = options.email
351
352     s = smtplib.SMTP()
353     s.connect()
354     s.sendmail(msg['From'], [msg['To']], msg.as_string())
355     s.quit()
356
357 (options, args) = parser.parse_args()
358
359 if options.retry:
360     if not options.rebase_master and options.rebase is None:
361         raise Exception('You can only use --retry if you also rebase')
362
363 testbase = "%s/b%u" % (options.testbase, os.getpid())
364 test_master = "%s/master" % testbase
365
366 gitroot = find_git_root()
367 if gitroot is None:
368     raise Exception("Failed to find git root")
369
370 try:
371     os.makedirs(testbase)
372 except Exception, reason:
373     raise Exception("Unable to create %s : %s" % (testbase, reason))
374 cleanup_list.append(testbase)
375
376 if options.daemon:
377     logfile = os.path.join(testbase, "log")
378     print "Forking into the background, writing progress to %s" % logfile
379     daemonize(logfile)
380
381 while True:
382     try:
383         run_cmd("rm -rf %s" % test_master)
384         cleanup_list.append(test_master)
385         run_cmd("git clone --shared %s %s" % (gitroot, test_master))
386     except:
387         cleanup()
388         raise
389
390     try:
391         if options.rebase is not None:
392             rebase_tree(options.rebase)
393         elif options.rebase_master:
394             rebase_tree(samba_master)
395         blist = buildlist(tasks, args)
396         if options.tail:
397             blist.start_tail()
398         (status, failed_task, failed_tag, errstr) = blist.run()
399         if status != 0 or errstr != "retry":
400             break
401         cleanup()
402     except:
403         cleanup()
404         raise
405
406 blist.kill_kids()
407 if options.tail:
408     print("waiting for tail to flush")
409     time.sleep(1)
410
411 if status == 0:
412     print errstr
413     if options.passcmd is not None:
414         print("Running passcmd: %s" % options.passcmd)
415         run_cmd(options.passcmd, dir=test_master)
416     if options.pushto is not None:
417         push_to(options.pushto)
418     elif options.push_master:
419         push_to(samba_master_ssh)
420     if options.keeplogs:
421         blist.tarlogs("logs.tar.gz")
422         print("Logs in logs.tar.gz")
423     blist.remove_logs()
424     cleanup()
425     print(errstr)
426     sys.exit(0)
427
428 # something failed, gather a tar of the logs
429 blist.tarlogs("logs.tar.gz")
430
431 if options.email is not None:
432     email_failure(status, failed_task, failed_tag, errstr)
433
434 cleanup()
435 print(errstr)
436 print("Logs in logs.tar.gz")
437 sys.exit(status)