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
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
|
# -*- test-case-name: buildbot.test.test_dependencies -*-
import time, os.path
from zope.interface import implements
from twisted.internet import reactor
from twisted.application import service, internet, strports
from twisted.python import log, runtime
from twisted.protocols import basic
from twisted.cred import portal, checkers
from twisted.spread import pb
from buildbot import interfaces, buildset, util, pbutil
from buildbot.status import builder
from buildbot.sourcestamp import SourceStamp
from buildbot.changes.maildir import MaildirService
from buildbot.process.properties import Properties
class BaseScheduler(service.MultiService, util.ComparableMixin):
"""
A Schduler creates BuildSets and submits them to the BuildMaster.
@ivar name: name of the scheduler
@ivar properties: additional properties specified in this
scheduler's configuration
@type properties: Properties object
"""
implements(interfaces.IScheduler)
def __init__(self, name, properties={}):
"""
@param name: name for this scheduler
@param properties: properties to be propagated from this scheduler
@type properties: dict
"""
service.MultiService.__init__(self)
self.name = name
self.properties = Properties()
self.properties.update(properties, "Scheduler")
self.properties.setProperty("scheduler", name, "Scheduler")
def __repr__(self):
# TODO: why can't id() return a positive number? %d is ugly.
return "<Scheduler '%s' at %d>" % (self.name, id(self))
def submitBuildSet(self, bs):
self.parent.submitBuildSet(bs)
def addChange(self, change):
pass
class BaseUpstreamScheduler(BaseScheduler):
implements(interfaces.IUpstreamScheduler)
def __init__(self, name, properties={}):
BaseScheduler.__init__(self, name, properties)
self.successWatchers = []
def subscribeToSuccessfulBuilds(self, watcher):
self.successWatchers.append(watcher)
def unsubscribeToSuccessfulBuilds(self, watcher):
self.successWatchers.remove(watcher)
def submitBuildSet(self, bs):
d = bs.waitUntilFinished()
d.addCallback(self.buildSetFinished)
BaseScheduler.submitBuildSet(self, bs)
def buildSetFinished(self, bss):
if not self.running:
return
if bss.getResults() == builder.SUCCESS:
ss = bss.getSourceStamp()
for w in self.successWatchers:
w(ss)
class Scheduler(BaseUpstreamScheduler):
"""The default Scheduler class will run a build after some period of time
called the C{treeStableTimer}, on a given set of Builders. It only pays
attention to a single branch. You you can provide a C{fileIsImportant}
function which will evaluate each Change to decide whether or not it
should trigger a new build.
"""
fileIsImportant = None
compare_attrs = ('name', 'treeStableTimer', 'builderNames', 'branch',
'fileIsImportant', 'properties', 'categories')
def __init__(self, name, branch, treeStableTimer, builderNames,
fileIsImportant=None, properties={}, categories=None):
"""
@param name: the name of this Scheduler
@param branch: The branch name that the Scheduler should pay
attention to. Any Change that is not on this branch
will be ignored. It can be set to None to only pay
attention to the default branch.
@param treeStableTimer: the duration, in seconds, for which the tree
must remain unchanged before a build will be
triggered. This is intended to avoid builds
of partially-committed fixes.
@param builderNames: a list of Builder names. When this Scheduler
decides to start a set of builds, they will be
run on the Builders named by this list.
@param fileIsImportant: A callable which takes one argument (a Change
instance) and returns True if the change is
worth building, and False if it is not.
Unimportant Changes are accumulated until the
build is triggered by an important change.
The default value of None means that all
Changes are important.
@param properties: properties to apply to all builds started from this
scheduler
@param categories: A list of categories of changes to accept
"""
BaseUpstreamScheduler.__init__(self, name, properties)
self.treeStableTimer = treeStableTimer
errmsg = ("The builderNames= argument to Scheduler must be a list "
"of Builder description names (i.e. the 'name' key of the "
"Builder specification dictionary)")
assert isinstance(builderNames, (list, tuple)), errmsg
for b in builderNames:
assert isinstance(b, str), errmsg
self.builderNames = builderNames
self.branch = branch
if fileIsImportant:
assert callable(fileIsImportant)
self.fileIsImportant = fileIsImportant
self.importantChanges = []
self.unimportantChanges = []
self.nextBuildTime = None
self.timer = None
self.categories = categories
def listBuilderNames(self):
return self.builderNames
def getPendingBuildTimes(self):
if self.nextBuildTime is not None:
return [self.nextBuildTime]
return []
def addChange(self, change):
if change.branch != self.branch:
log.msg("%s ignoring off-branch %s" % (self, change))
return
if self.categories is not None and change.category not in self.categories:
log.msg("%s ignoring non-matching categories %s" % (self, change))
return
if not self.fileIsImportant:
self.addImportantChange(change)
elif self.fileIsImportant(change):
self.addImportantChange(change)
else:
self.addUnimportantChange(change)
def addImportantChange(self, change):
log.msg("%s: change is important, adding %s" % (self, change))
self.importantChanges.append(change)
self.nextBuildTime = max(self.nextBuildTime,
change.when + self.treeStableTimer)
self.setTimer(self.nextBuildTime)
def addUnimportantChange(self, change):
log.msg("%s: change is not important, adding %s" % (self, change))
self.unimportantChanges.append(change)
def setTimer(self, when):
log.msg("%s: setting timer to %s" %
(self, time.strftime("%H:%M:%S", time.localtime(when))))
now = util.now()
if when < now:
when = now
if self.timer:
self.timer.cancel()
self.timer = reactor.callLater(when - now, self.fireTimer)
def stopTimer(self):
if self.timer:
self.timer.cancel()
self.timer = None
def fireTimer(self):
# clear out our state
self.timer = None
self.nextBuildTime = None
changes = self.importantChanges + self.unimportantChanges
self.importantChanges = []
self.unimportantChanges = []
# create a BuildSet, submit it to the BuildMaster
bs = buildset.BuildSet(self.builderNames,
SourceStamp(changes=changes),
properties=self.properties)
self.submitBuildSet(bs)
def stopService(self):
self.stopTimer()
return service.MultiService.stopService(self)
class AnyBranchScheduler(BaseUpstreamScheduler):
"""This Scheduler will handle changes on a variety of branches. It will
accumulate Changes for each branch separately. It works by creating a
separate Scheduler for each new branch it sees."""
schedulerFactory = Scheduler
fileIsImportant = None
compare_attrs = ('name', 'branches', 'treeStableTimer', 'builderNames',
'fileIsImportant', 'properties')
def __init__(self, name, branches, treeStableTimer, builderNames,
fileIsImportant=None, properties={}):
"""
@param name: the name of this Scheduler
@param branches: The branch names that the Scheduler should pay
attention to. Any Change that is not on one of these
branches will be ignored. It can be set to None to
accept changes from any branch. Don't use [] (an
empty list), because that means we don't pay
attention to *any* branches, so we'll never build
anything.
@param treeStableTimer: the duration, in seconds, for which the tree
must remain unchanged before a build will be
triggered. This is intended to avoid builds
of partially-committed fixes.
@param builderNames: a list of Builder names. When this Scheduler
decides to start a set of builds, they will be
run on the Builders named by this list.
@param fileIsImportant: A callable which takes one argument (a Change
instance) and returns True if the change is
worth building, and False if it is not.
Unimportant Changes are accumulated until the
build is triggered by an important change.
The default value of None means that all
Changes are important.
@param properties: properties to apply to all builds started from this
scheduler
"""
BaseUpstreamScheduler.__init__(self, name, properties)
self.treeStableTimer = treeStableTimer
for b in builderNames:
assert isinstance(b, str)
self.builderNames = builderNames
self.branches = branches
if self.branches == []:
log.msg("AnyBranchScheduler %s: branches=[], so we will ignore "
"all branches, and never trigger any builds. Please set "
"branches=None to mean 'all branches'" % self)
# consider raising an exception here, to make this warning more
# prominent, but I can vaguely imagine situations where you might
# want to comment out branches temporarily and wouldn't
# appreciate it being treated as an error.
if fileIsImportant:
assert callable(fileIsImportant)
self.fileIsImportant = fileIsImportant
self.schedulers = {} # one per branch
def __repr__(self):
return "<AnyBranchScheduler '%s'>" % self.name
def listBuilderNames(self):
return self.builderNames
def getPendingBuildTimes(self):
bts = []
for s in self.schedulers.values():
if s.nextBuildTime is not None:
bts.append(s.nextBuildTime)
return bts
def buildSetFinished(self, bss):
# we don't care if a build has finished; one of the per-branch builders
# will take care of it, instead.
pass
def addChange(self, change):
branch = change.branch
if self.branches is not None and branch not in self.branches:
log.msg("%s ignoring off-branch %s" % (self, change))
return
s = self.schedulers.get(branch)
if not s:
if branch:
name = self.name + "." + branch
else:
name = self.name + ".<default>"
s = self.schedulerFactory(name, branch,
self.treeStableTimer,
self.builderNames,
self.fileIsImportant)
s.successWatchers = self.successWatchers
s.setServiceParent(self)
s.properties = self.properties
# TODO: does this result in schedulers that stack up forever?
# When I make the persistify-pass, think about this some more.
self.schedulers[branch] = s
s.addChange(change)
class Dependent(BaseUpstreamScheduler):
"""This scheduler runs some set of 'downstream' builds when the
'upstream' scheduler has completed successfully."""
implements(interfaces.IDownstreamScheduler)
compare_attrs = ('name', 'upstream', 'builderNames', 'properties')
def __init__(self, name, upstream, builderNames, properties={}):
assert interfaces.IUpstreamScheduler.providedBy(upstream)
BaseUpstreamScheduler.__init__(self, name, properties)
self.upstream = upstream
self.builderNames = builderNames
def listBuilderNames(self):
return self.builderNames
def getPendingBuildTimes(self):
# report the upstream's value
return self.upstream.getPendingBuildTimes()
def startService(self):
service.MultiService.startService(self)
self.upstream.subscribeToSuccessfulBuilds(self.upstreamBuilt)
def stopService(self):
d = service.MultiService.stopService(self)
self.upstream.unsubscribeToSuccessfulBuilds(self.upstreamBuilt)
return d
def upstreamBuilt(self, ss):
bs = buildset.BuildSet(self.builderNames, ss,
properties=self.properties)
self.submitBuildSet(bs)
def checkUpstreamScheduler(self):
# find our *active* upstream scheduler (which may not be self.upstream!) by name
up_name = self.upstream.name
upstream = None
for s in self.parent.allSchedulers():
if s.name == up_name and interfaces.IUpstreamScheduler.providedBy(s):
upstream = s
if not upstream:
log.msg("ERROR: Couldn't find upstream scheduler of name <%s>" %
up_name)
# if it's already correct, we're good to go
if upstream is self.upstream:
return
# otherwise, associate with the new upstream. We also keep listening
# to the old upstream, in case it's in the middle of a build
upstream.subscribeToSuccessfulBuilds(self.upstreamBuilt)
self.upstream = upstream
log.msg("Dependent <%s> connected to new Upstream <%s>" %
(self.name, up_name))
class Periodic(BaseUpstreamScheduler):
"""Instead of watching for Changes, this Scheduler can just start a build
at fixed intervals. The C{periodicBuildTimer} parameter sets the number
of seconds to wait between such periodic builds. The first build will be
run immediately."""
# TODO: consider having this watch another (changed-based) scheduler and
# merely enforce a minimum time between builds.
compare_attrs = ('name', 'builderNames', 'periodicBuildTimer', 'branch', 'properties')
def __init__(self, name, builderNames, periodicBuildTimer,
branch=None, properties={}):
BaseUpstreamScheduler.__init__(self, name, properties)
self.builderNames = builderNames
self.periodicBuildTimer = periodicBuildTimer
self.branch = branch
self.reason = ("The Periodic scheduler named '%s' triggered this build"
% name)
self.timer = internet.TimerService(self.periodicBuildTimer,
self.doPeriodicBuild)
self.timer.setServiceParent(self)
def listBuilderNames(self):
return self.builderNames
def getPendingBuildTimes(self):
# TODO: figure out when self.timer is going to fire next and report
# that
return []
def doPeriodicBuild(self):
bs = buildset.BuildSet(self.builderNames,
SourceStamp(branch=self.branch),
self.reason,
properties=self.properties)
self.submitBuildSet(bs)
class Nightly(BaseUpstreamScheduler):
"""Imitate 'cron' scheduling. This can be used to schedule a nightly
build, or one which runs are certain times of the day, week, or month.
Pass some subset of minute, hour, dayOfMonth, month, and dayOfWeek; each
may be a single number or a list of valid values. The builds will be
triggered whenever the current time matches these values. Wildcards are
represented by a '*' string. All fields default to a wildcard except
'minute', so with no fields this defaults to a build every hour, on the
hour.
For example, the following master.cfg clause will cause a build to be
started every night at 3:00am::
s = Nightly('nightly', ['builder1', 'builder2'], hour=3, minute=0)
c['schedules'].append(s)
This scheduler will perform a build each monday morning at 6:23am and
again at 8:23am::
s = Nightly('BeforeWork', ['builder1'],
dayOfWeek=0, hour=[6,8], minute=23)
The following runs a build every two hours::
s = Nightly('every2hours', ['builder1'], hour=range(0, 24, 2))
And this one will run only on December 24th::
s = Nightly('SleighPreflightCheck', ['flying_circuits', 'radar'],
month=12, dayOfMonth=24, hour=12, minute=0)
For dayOfWeek and dayOfMonth, builds are triggered if the date matches
either of them. All time values are compared against the tuple returned
by time.localtime(), so month and dayOfMonth numbers start at 1, not
zero. dayOfWeek=0 is Monday, dayOfWeek=6 is Sunday.
onlyIfChanged functionality
s = Nightly('nightly', ['builder1', 'builder2'],
hour=3, minute=0, onlyIfChanged=True)
When the flag is True (False by default), the build is trigged if
the date matches and if the branch has changed
fileIsImportant parameter is implemented as defined in class Scheduler
"""
compare_attrs = ('name', 'builderNames',
'minute', 'hour', 'dayOfMonth', 'month',
'dayOfWeek', 'branch', 'onlyIfChanged',
'fileIsImportant', 'properties')
def __init__(self, name, builderNames, minute=0, hour='*',
dayOfMonth='*', month='*', dayOfWeek='*',
branch=None, fileIsImportant=None, onlyIfChanged=False, properties={}):
# Setting minute=0 really makes this an 'Hourly' scheduler. This
# seemed like a better default than minute='*', which would result in
# a build every 60 seconds.
BaseUpstreamScheduler.__init__(self, name, properties)
self.builderNames = builderNames
self.minute = minute
self.hour = hour
self.dayOfMonth = dayOfMonth
self.month = month
self.dayOfWeek = dayOfWeek
self.branch = branch
self.onlyIfChanged = onlyIfChanged
self.delayedRun = None
self.nextRunTime = None
self.reason = ("The Nightly scheduler named '%s' triggered this build"
% name)
self.importantChanges = []
self.unimportantChanges = []
self.fileIsImportant = None
if fileIsImportant:
assert callable(fileIsImportant)
self.fileIsImportant = fileIsImportant
def addTime(self, timetuple, secs):
return time.localtime(time.mktime(timetuple)+secs)
def findFirstValueAtLeast(self, values, value, default=None):
for v in values:
if v >= value: return v
return default
def setTimer(self):
self.nextRunTime = self.calculateNextRunTime()
self.delayedRun = reactor.callLater(self.nextRunTime - time.time(),
self.doPeriodicBuild)
def startService(self):
BaseUpstreamScheduler.startService(self)
self.setTimer()
def stopService(self):
BaseUpstreamScheduler.stopService(self)
self.delayedRun.cancel()
def isRunTime(self, timetuple):
def check(ourvalue, value):
if ourvalue == '*': return True
if isinstance(ourvalue, int): return value == ourvalue
return (value in ourvalue)
if not check(self.minute, timetuple[4]):
#print 'bad minute', timetuple[4], self.minute
return False
if not check(self.hour, timetuple[3]):
#print 'bad hour', timetuple[3], self.hour
return False
if not check(self.month, timetuple[1]):
#print 'bad month', timetuple[1], self.month
return False
if self.dayOfMonth != '*' and self.dayOfWeek != '*':
# They specified both day(s) of month AND day(s) of week.
# This means that we only have to match one of the two. If
# neither one matches, this time is not the right time.
if not (check(self.dayOfMonth, timetuple[2]) or
check(self.dayOfWeek, timetuple[6])):
#print 'bad day'
return False
else:
if not check(self.dayOfMonth, timetuple[2]):
#print 'bad day of month'
return False
if not check(self.dayOfWeek, timetuple[6]):
#print 'bad day of week'
return False
return True
def calculateNextRunTime(self):
return self.calculateNextRunTimeFrom(time.time())
def calculateNextRunTimeFrom(self, now):
dateTime = time.localtime(now)
# Remove seconds by advancing to at least the next minue
dateTime = self.addTime(dateTime, 60-dateTime[5])
# Now we just keep adding minutes until we find something that matches
# It not an efficient algorithm, but it'll *work* for now
yearLimit = dateTime[0]+2
while not self.isRunTime(dateTime):
dateTime = self.addTime(dateTime, 60)
#print 'Trying', time.asctime(dateTime)
assert dateTime[0] < yearLimit, 'Something is wrong with this code'
return time.mktime(dateTime)
def listBuilderNames(self):
return self.builderNames
def getPendingBuildTimes(self):
# TODO: figure out when self.timer is going to fire next and report
# that
if self.nextRunTime is None: return []
return [self.nextRunTime]
def doPeriodicBuild(self):
# Schedule the next run
self.setTimer()
if self.onlyIfChanged:
if len(self.importantChanges) > 0:
changes = self.importantChanges + self.unimportantChanges
# And trigger a build
log.msg("Nightly Scheduler <%s>: triggering build" % self.name)
bs = buildset.BuildSet(self.builderNames,
SourceStamp(changes=changes),
self.reason,
properties=self.properties)
self.submitBuildSet(bs)
# Reset the change lists
self.importantChanges = []
self.unimportantChanges = []
else:
log.msg("Nightly Scheduler <%s>: skipping build - No important change" % self.name)
else:
# And trigger a build
bs = buildset.BuildSet(self.builderNames,
SourceStamp(branch=self.branch),
self.reason,
properties=self.properties)
self.submitBuildSet(bs)
def addChange(self, change):
if self.onlyIfChanged:
if change.branch != self.branch:
log.msg("Nightly Scheduler <%s>: ignoring change %d on off-branch %s" % (self.name, change.revision, change.branch))
return
if not self.fileIsImportant:
self.addImportantChange(change)
elif self.fileIsImportant(change):
self.addImportantChange(change)
else:
self.addUnimportantChange(change)
else:
log.msg("Nightly Scheduler <%s>: no add change" % self.name)
pass
def addImportantChange(self, change):
log.msg("Nightly Scheduler <%s>: change %s from %s is important, adding it" % (self.name, change.revision, change.who))
self.importantChanges.append(change)
def addUnimportantChange(self, change):
log.msg("Nightly Scheduler <%s>: change %s from %s is not important, adding it" % (self.name, change.revision, change.who))
self.unimportantChanges.append(change)
class TryBase(BaseScheduler):
def __init__(self, name, builderNames, properties={}):
BaseScheduler.__init__(self, name, properties)
self.builderNames = builderNames
def listBuilderNames(self):
return self.builderNames
def getPendingBuildTimes(self):
# we can't predict what the developers are going to do in the future
return []
def addChange(self, change):
# Try schedulers ignore Changes
pass
def processBuilderList(self, builderNames):
# self.builderNames is the configured list of builders
# available for try. If the user supplies a list of builders,
# it must be restricted to the configured list. If not, build
# on all of the configured builders.
if builderNames:
for b in builderNames:
if not b in self.builderNames:
log.msg("%s got with builder %s" % (self, b))
log.msg(" but that wasn't in our list: %s"
% (self.builderNames,))
return []
else:
builderNames = self.builderNames
return builderNames
class BadJobfile(Exception):
pass
class JobFileScanner(basic.NetstringReceiver):
def __init__(self):
self.strings = []
self.transport = self # so transport.loseConnection works
self.error = False
def stringReceived(self, s):
self.strings.append(s)
def loseConnection(self):
self.error = True
class Try_Jobdir(TryBase):
compare_attrs = ( 'name', 'builderNames', 'jobdir', 'properties' )
def __init__(self, name, builderNames, jobdir, properties={}):
TryBase.__init__(self, name, builderNames, properties)
self.jobdir = jobdir
self.watcher = MaildirService()
self.watcher.setServiceParent(self)
def setServiceParent(self, parent):
self.watcher.setBasedir(os.path.join(parent.basedir, self.jobdir))
TryBase.setServiceParent(self, parent)
def parseJob(self, f):
# jobfiles are serialized build requests. Each is a list of
# serialized netstrings, in the following order:
# "1", the version number of this format
# buildsetID, arbitrary string, used to find the buildSet later
# branch name, "" for default-branch
# base revision, "" for HEAD
# patchlevel, usually "1"
# patch
# builderNames...
p = JobFileScanner()
p.dataReceived(f.read())
if p.error:
raise BadJobfile("unable to parse netstrings")
s = p.strings
ver = s.pop(0)
if ver != "1":
raise BadJobfile("unknown version '%s'" % ver)
buildsetID, branch, baserev, patchlevel, diff = s[:5]
builderNames = s[5:]
if branch == "":
branch = None
if baserev == "":
baserev = None
patchlevel = int(patchlevel)
patch = (patchlevel, diff)
ss = SourceStamp(branch, baserev, patch)
return builderNames, ss, buildsetID
def messageReceived(self, filename):
md = os.path.join(self.parent.basedir, self.jobdir)
if runtime.platformType == "posix":
# open the file before moving it, because I'm afraid that once
# it's in cur/, someone might delete it at any moment
path = os.path.join(md, "new", filename)
f = open(path, "r")
os.rename(os.path.join(md, "new", filename),
os.path.join(md, "cur", filename))
else:
# do this backwards under windows, because you can't move a file
# that somebody is holding open. This was causing a Permission
# Denied error on bear's win32-twisted1.3 buildslave.
os.rename(os.path.join(md, "new", filename),
os.path.join(md, "cur", filename))
path = os.path.join(md, "cur", filename)
f = open(path, "r")
try:
builderNames, ss, bsid = self.parseJob(f)
except BadJobfile:
log.msg("%s reports a bad jobfile in %s" % (self, filename))
log.err()
return
# Validate/fixup the builder names.
builderNames = self.processBuilderList(builderNames)
if not builderNames:
return
reason = "'try' job"
bs = buildset.BuildSet(builderNames, ss, reason=reason,
bsid=bsid, properties=self.properties)
self.submitBuildSet(bs)
class Try_Userpass(TryBase):
compare_attrs = ( 'name', 'builderNames', 'port', 'userpass', 'properties' )
implements(portal.IRealm)
def __init__(self, name, builderNames, port, userpass, properties={}):
TryBase.__init__(self, name, builderNames, properties)
if type(port) is int:
port = "tcp:%d" % port
self.port = port
self.userpass = userpass
c = checkers.InMemoryUsernamePasswordDatabaseDontUse()
for user,passwd in self.userpass:
c.addUser(user, passwd)
p = portal.Portal(self)
p.registerChecker(c)
f = pb.PBServerFactory(p)
s = strports.service(port, f)
s.setServiceParent(self)
def getPort(self):
# utility method for tests: figure out which TCP port we just opened.
return self.services[0]._port.getHost().port
def requestAvatar(self, avatarID, mind, interface):
log.msg("%s got connection from user %s" % (self, avatarID))
assert interface == pb.IPerspective
p = Try_Userpass_Perspective(self, avatarID)
return (pb.IPerspective, p, lambda: None)
class Try_Userpass_Perspective(pbutil.NewCredPerspective):
def __init__(self, parent, username):
self.parent = parent
self.username = username
def perspective_try(self, branch, revision, patch, builderNames, properties={}):
log.msg("user %s requesting build on builders %s" % (self.username,
builderNames))
# Validate/fixup the builder names.
builderNames = self.parent.processBuilderList(builderNames)
if not builderNames:
return
ss = SourceStamp(branch, revision, patch)
reason = "'try' job from user %s" % self.username
# roll the specified props in with our inherited props
combined_props = Properties()
combined_props.updateFromProperties(self.parent.properties)
combined_props.update(properties, "try build")
bs = buildset.BuildSet(builderNames,
ss,
reason=reason,
properties=combined_props)
self.parent.submitBuildSet(bs)
# return a remotely-usable BuildSetStatus object
from buildbot.status.client import makeRemote
return makeRemote(bs.status)
class Triggerable(BaseUpstreamScheduler):
"""This scheduler doesn't do anything until it is triggered by a Trigger
step in a factory. In general, that step will not complete until all of
the builds that I fire have finished.
"""
compare_attrs = ('name', 'builderNames', 'properties')
def __init__(self, name, builderNames, properties={}):
BaseUpstreamScheduler.__init__(self, name, properties)
self.builderNames = builderNames
def listBuilderNames(self):
return self.builderNames
def getPendingBuildTimes(self):
return []
def trigger(self, ss, set_props=None):
"""Trigger this scheduler. Returns a deferred that will fire when the
buildset is finished.
"""
# properties for this buildset are composed of our own properties,
# potentially overridden by anything from the triggering build
props = Properties()
props.updateFromProperties(self.properties)
if set_props: props.updateFromProperties(set_props)
bs = buildset.BuildSet(self.builderNames, ss, properties=props)
d = bs.waitUntilFinished()
self.submitBuildSet(bs)
return d
|