def _ComputeSchedulers(builders):
scheduler_to_builders = {}
for builder_name, builder_data in builders['builders'].items():
scheduler_names = builder_data.get('schedulers', [])
if 'scheduler' in builder_data:
scheduler_names.append(builder_data['scheduler'])
for scheduler_name in scheduler_names:
if scheduler_name:
if scheduler_name not in builders['schedulers']:
raise ValueError('unknown scheduler "%s"' % scheduler_name)
scheduler_to_builders.setdefault(scheduler_name,
[]).append(builder_name)
schedulers = []
for scheduler_name, scheduler_values in builders['schedulers'].items():
scheduler_type = scheduler_values['type']
builder_names = scheduler_to_builders[scheduler_name]
if scheduler_type == 'git_poller':
# git_poller pollers group changes, so we match on our specific repository
# to ensure that we only pick up changes from our poller.
schedulers.append(
SingleBranchScheduler(
name=scheduler_name,
change_filter=ChangeFilter(
repository=scheduler_values['git_repo_url'],
branch=scheduler_values.get('branch', 'master'),
),
treeStableTimer=scheduler_values.get(
'treeStableTimer', 60),
builderNames=builder_names))
elif scheduler_type == 'repo_poller':
# repo_poller pollers punt changes that use the scheduler name as their
# category (see _ComputeChangeSourceAndTagComparator). Matching on this
# ensures that we only match changes from our poller.
schedulers.append(
SingleBranchScheduler(name=scheduler_name,
change_filter=ChangeFilter(
category=str(scheduler_name), ),
treeStableTimer=scheduler_values.get(
'treeStableTimer', 60),
builderNames=builder_names))
elif scheduler_type == 'cron':
schedulers.append(
Nightly(name=scheduler_name,
branch='master',
minute=scheduler_values['minute'],
hour=scheduler_values['hour'],
builderNames=builder_names))
else:
raise ValueError('unsupported scheduler type "%s"' %
scheduler_type)
return schedulers
def Update(c):
c['schedulers'].extend([
SingleBranchScheduler(name='webrtc_windows_scheduler',
branch='master',
treeStableTimer=0,
builderNames=[
'Win32 Release (swarming)',
]),
])
specs = [
{
'name': 'Win32 Release (swarming)',
'slavebuilddir': 'win_swarming',
},
]
c['builders'].extend([{
'name':
spec['name'],
'factory':
m_annotator.BaseFactory('webrtc/standalone'),
'notify_on_missing':
True,
'category':
'win',
'slavebuilddir':
spec['slavebuilddir'],
} for spec in specs])
def Update(c):
c['schedulers'].extend([
SingleBranchScheduler(name='linux_rel_scheduler',
branch='master',
treeStableTimer=60,
builderNames=['Linux Builder']),
Triggerable(name='linux_rel_trigger',
builderNames=['Linux Tester']),
])
specs = [
{
'name': 'Linux Builder',
'triggers': ['linux_rel_trigger'],
},
{'name': 'Linux Tester'},
]
c['builders'].extend([
{
'name': spec['name'],
'factory': m_annotator.BaseFactory(
'webrtc/chromium',
triggers=spec.get('triggers')),
'category': 'linux',
'notify_on_missing': True,
} for spec in specs
])
def Update(c):
c['schedulers'].extend([
SingleBranchScheduler(name='android_webrtc_scheduler',
branch='master',
treeStableTimer=60,
builderNames=['Android Builder (dbg)']),
Triggerable(name='android_trigger_dbg', builderNames=[
'Android Tests (dbg) (KK Nexus5)',
'Android Tests (dbg) (JB Nexus7.2)',
]),
])
specs = [
{
'name': 'Android Builder (dbg)',
'triggers': ['android_trigger_dbg'],
},
{'name': 'Android Tests (dbg) (KK Nexus5)'},
{'name': 'Android Tests (dbg) (JB Nexus7.2)'},
]
c['builders'].extend([
{
'name': spec['name'],
'factory': m_annotator.BaseFactory(
'webrtc/chromium',
triggers=spec.get('triggers')),
'category': 'android',
'notify_on_missing': True,
} for spec in specs
])
def Update(_config, active_master, c):
c['schedulers'].extend([
SingleBranchScheduler(name='mac_asan_rel',
branch='master',
treeStableTimer=60,
builderNames=[
'Mac ASan 64 Builder',
]),
Triggerable(name='mac_asan_64_rel_trigger',
builderNames=[
'Mac ASan 64 Tests (1)',
]),
])
specs = [
{
'name': 'Mac ASan 64 Builder',
'triggers': ['mac_asan_64_rel_trigger'],
},
{
'name': 'Mac ASan 64 Tests (1)'
},
]
c['builders'].extend([{
'name':
spec['name'],
'factory':
m_remote_run('chromium', triggers=spec.get('triggers')),
'notify_on_missing':
True,
'category':
'2mac asan',
} for spec in specs])
def Update(c):
c['schedulers'].extend([
SingleBranchScheduler(name='webrtc_mac_scheduler',
branch='master',
treeStableTimer=0,
builderNames=[
'Mac64 Release (swarming)',
]),
])
specs = [
{
'name': 'Mac64 Release (swarming)',
'slavebuilddir': 'mac_swarming'
},
]
c['builders'].extend([{
'name':
spec['name'],
'factory':
m_annotator.BaseFactory(spec.get('recipe', 'webrtc/standalone')),
'notify_on_missing':
True,
'category':
'mac',
'slavebuilddir':
spec['slavebuilddir'],
} for spec in specs])
def sample_slave(c):
#create a new slave in the master's database
c['slaves'].append(BuildSlave("sample_slave_name", "password"))
# build the tree whenever the change poller notices a change
c['schedulers'].append(
SingleBranchScheduler(
name="master",
change_filter=filter.ChangeFilter(branch='master'),
treeStableTimer=60,
fileIsImportant=shouldBuildTrigger,
builderNames=["sample_builder_name"]))
# Allow authenticated (to the buildmaster) users to force a build
# Optionally, force a full build, i.e. 'git clean -f -d -x' instead
# of a incremental build (essentially 'git pull && make)
c['schedulers'].append(
ForceScheduler(name="a name for your forcescheduler",
branch=FixedParameter(name="branch", default=""),
revision=FixedParameter(name="revision", default=""),
repository=FixedParameter(name="repository",
default=""),
project=FixedParameter(name="repository", default=""),
builderNames=["sample_LLVM_builder_name"],
properties=[
ChoiceStringParameter(
name="git_mode",
label="how to update git (see buildbot docs)",
choices=["incremental", "full"],
default="incremental")
]))
#create one set of steps to build pocl. See poclfactory.py for
#parameters to pass this function.
#You can create as many factories+builders as your slave has space & need for
#e.g. one per LLVM version, or different build options for pocl
sample_factory = createPoclFactory()
#register your build to the master
c['builders'].append(
BuilderConfig(name="sample_builder_name",
slavenames=["sample_slave_name"],
factory=sample_factory))
#create one set of steps to build latest LLVM. This is a check for if LLVM
# has introduced regressions (e.g. API changes, asserts or codegen issues)
# This factory:
# - builds LLVM from svn & runs its checks
# - installs LLVM to a temporary directory
# - builds & checks pocl against this LLVM
# - installs the built LLVM into a permanent directory
# You want also a pocl factory/builder to run against this second installation LLVM
# to check if pocl has introduced regressions.
#. See poclfactory.py for parameters to pass this function
sample_LLVM_factory = createLLVMFactory()
c['builders'].append(
BuilderConfig(name="sample_LLVM_builder_name",
slavenames=["sample_slave_name"],
factory=sample_LLVM_factory))
def Update(_config, active_master, c):
c['schedulers'].append(
SingleBranchScheduler(name='chromium_simplechrome',
branch='master',
treeStableTimer=60,
builderNames=[b['name'] for b in builders]))
c['builders'] += builders
def make_schedulers(self):
"""We make one scheduler per build factory (ie per buildout).
Indeed, a scheduler must be tied to a list of builders to run.
TODO at some point check if a big dedicated, single schedulers would
not be preferable for buildmaster performance.
"""
schedulers = []
for factory_name, builders in self.factories_to_builders.items():
options = self.build_factories[factory_name].options
tree_stable_timer = options.get('tree-stable-timer')
if tree_stable_timer is not None:
tree_stable_timer = int(tree_stable_timer.strip())
else:
tree_stable_timer = self.tree_stable_timer
change_filter = self.watcher.change_filter(factory_name)
if change_filter is None:
continue
schedulers.append(
SingleBranchScheduler(name=factory_name,
change_filter=change_filter,
treeStableTimer=tree_stable_timer,
builderNames=builders))
log.msg("Scheduler %r is for builders %r "
"with %r" % (factory_name, builders, change_filter))
return schedulers
def Update(config, active_master, c):
c['schedulers'].extend([
SingleBranchScheduler(name='win_src',
branch='master',
treeStableTimer=60,
builderNames=[
'Win Builder',
'Win x64 Builder',
'Win x64 Builder (dbg)',
'Win Builder (dbg)',
'Win8 GYP (dbg)',
'WinClang64 (dbg)',
'Win8 GYP',
]),
])
specs = [
{
'name': 'Win Builder'
},
{
'name': 'Win7 (32) Tests'
},
{
'name': 'Win7 Tests (1)'
},
{
'name': 'Win x64 Builder'
},
{
'name': 'Win 7 Tests x64 (1)'
},
{
'name': 'Win x64 Builder (dbg)'
},
{
'name': 'Win Builder (dbg)'
},
{
'name': 'Win7 Tests (dbg)(1)'
},
{
'name': 'Win8 GYP'
},
{
'name': 'Win8 GYP (dbg)'
},
{
'name': 'WinClang64 (dbg)'
},
{
'name': 'Win10 Tests x64'
},
]
c['builders'].extend([{
'name': spec['name'],
'factory': m_remote_run('chromium'),
'notify_on_missing': True,
'category': '2windows',
} for spec in specs])
def Update(config, active_master, c):
c['schedulers'].extend([
SingleBranchScheduler(name='ios',
branch='master',
treeStableTimer=60,
builderNames=[
'iOS Device',
'iOS Simulator (dbg)',
'iOS Device (ninja)',
]),
])
specs = [
{'name': 'iOS Device'},
{'name': 'iOS Simulator (dbg)'},
{'name': 'iOS Device (ninja)'},
]
c['builders'].extend([
{
'name': spec['name'],
'factory': m_annotator.BaseFactory(
'chromium',
factory_properties=spec.get('factory_properties'),
triggers=spec.get('triggers')),
'notify_on_missing': True,
'category': '3mac',
} for spec in specs
])
def Update(_config, active_master, c):
c['schedulers'].extend([
SingleBranchScheduler(name='linux_asan_rel',
branch='master',
treeStableTimer=60,
builderNames=[
'Linux ASan LSan Builder'
]),
Triggerable(name='linux_asan_rel_trigger', builderNames=[
'Linux ASan LSan Tests (1)',
'Linux ASan Tests (sandboxed)',
]),
])
specs = [
{
'name': 'Linux ASan LSan Builder',
'triggers': ['linux_asan_rel_trigger'],
},
{'name': 'Linux ASan LSan Tests (1)'},
{'name': 'Linux ASan Tests (sandboxed)'},
]
c['builders'].extend([
{
'name': spec['name'],
'factory': m_annotator.BaseFactory(
spec.get('recipe', 'chromium'),
triggers=spec.get('triggers')),
'notify_on_missing': True,
'category': '1linux asan lsan',
} for spec in specs
])
def sample_slave(c, common_branch):
#create a new slave in the master's database
c['slaves'].append(BuildSlave("sample_slave_name", "password"))
# lauch the builders listed in "builderNames" whenever the change poller notices a change to github pocl
c['schedulers'].append(
SingleBranchScheduler(
name="name for scheduler, not sure where this is used",
change_filter=filter.ChangeFilter(branch=common_branch),
treeStableTimer=60,
builderNames=[
"sample_builder_name - this is the name that appears on the webpage"
]))
#create one set of steps to build pocl. See poclfactory.py for details
# on how to configure it
sample_factory = createPoclFactory()
#register your build to the master
c['builders'].append(
BuilderConfig(
name=
"sample_builder_name - this is the name that appears on the webpage",
slavenames=["sample_slave_name"],
factory=sample_factory))
def Update(config, active_master, c):
c['schedulers'].extend([
SingleBranchScheduler(name='ios',
branch='master',
treeStableTimer=60,
builderNames=[
'ios-device',
'ios-device-gn',
'ios-simulator',
'ios-simulator-gn',
]),
])
specs = [
{'name': 'ios-device'},
{'name': 'ios-device-gn'},
{'name': 'ios-simulator'},
{'name': 'ios-simulator-gn'},
]
c['builders'].extend([
{
'name': spec['name'],
'factory': m_annotator.BaseFactory(
'ios/unified_builder_tester',
factory_properties=spec.get('factory_properties')),
'notify_on_missing': True,
'category': '3mac',
} for spec in specs
])
def Update(_config_arg, _active_master, c):
helper.Update(c)
specs = [
{
'name': 'Android GN'
},
{
'name': 'Android GN (dbg)'
},
{
'name': 'Cast Android (dbg)'
},
]
c['schedulers'].extend([
SingleBranchScheduler(name='android_gn',
branch='master',
treeStableTimer=60,
builderNames=[s['name'] for s in specs]),
])
c['builders'].extend([{
'name':
spec['name'],
'factory':
m_annotator.BaseFactory(
spec.get('recipe', 'chromium'),
factory_properties=spec.get('factory_properties')),
'notify_on_missing':
True,
'category':
'5android',
} for spec in specs])
def Update(c):
c['schedulers'].extend([
SingleBranchScheduler(name='libyuv_android_scheduler',
branch='trunk',
treeStableTimer=0,
builderNames=[
'Android Debug',
'Android Release',
'Android Clang Debug',
'Android ARM64 Debug',
]),
])
specs = [
{'name': 'Android Debug'},
{'name': 'Android Release'},
{'name': 'Android Clang Debug', 'slavebuilddir': 'android_clang' },
{'name': 'Android ARM64 Debug', 'slavebuilddir': 'android_arm64' },
]
c['builders'].extend([
{
'name': spec['name'],
'factory': m_annotator.BaseFactory('libyuv/libyuv'),
'notify_on_missing': True,
'category': 'android',
'slavebuilddir': spec.get('slavebuilddir', 'android'),
} for spec in specs
])
def Update(c):
buildernames_list = ['Win Builder']
c['schedulers'].extend([
SingleBranchScheduler(name='win_webrtc_scheduler',
branch='trunk',
treeStableTimer=0,
builderNames=buildernames_list),
Periodic(name='win_periodic_scheduler',
periodicBuildTimer=4*60*60,
builderNames=buildernames_list),
Triggerable(name='win_rel_trigger', builderNames=[
'WinXP Tester',
'Win7 Tester',
]),
])
specs = [
{
'name': 'Win Builder',
'triggers': ['win_rel_trigger'],
},
{'name': 'WinXP Tester'},
{'name': 'Win7 Tester'},
]
c['builders'].extend([
{
'name': spec['name'],
'factory': m_annotator.BaseFactory(
'webrtc/chromium',
triggers=spec.get('triggers')),
'category': 'win',
'notify_on_missing': True,
} for spec in specs
])
def Update(c):
c['schedulers'].extend([
SingleBranchScheduler(name='libyuv_linux_scheduler',
branch='trunk',
treeStableTimer=0,
builderNames=[
'Linux32 Debug',
'Linux32 Release',
'Linux64 Debug',
'Linux64 Release',
'Linux Asan',
'Linux Memcheck',
'Linux Tsan v2',
]),
])
specs = [
{'name': 'Linux32 Debug', 'slavebuilddir': 'linux32'},
{'name': 'Linux32 Release', 'slavebuilddir': 'linux32'},
{'name': 'Linux64 Debug', 'slavebuilddir': 'linux64'},
{'name': 'Linux64 Release', 'slavebuilddir': 'linux64'},
{'name': 'Linux Asan', 'slavebuilddir': 'linux_asan'},
{'name': 'Linux Memcheck', 'slavebuilddir': 'linux_memcheck_tsan'},
{'name': 'Linux Tsan v2', 'slavebuilddir': 'linux_tsan2'},
]
c['builders'].extend([
{
'name': spec['name'],
'factory': m_annotator.BaseFactory('libyuv/libyuv'),
'notify_on_missing': True,
'category': 'linux',
'slavebuilddir': spec['slavebuilddir'],
} for spec in specs
])
def get_schedulers(builders):
platforms = ["linux", "osx", "win"]
schedulers = []
for platform in platforms:
platform_builders = [b for b in builders if platform in b.name]
# Unit tests for this platform
unit_builders = [b.name for b in platform_builders if "unit" in b.name]
master_unit = SingleBranchScheduler(
name="%s-master-unit" % platform,
change_filter=ChangeFilter(branch="master"),
treeStableTimer=60,
builderNames=unit_builders)
acceptance_builders = [
b.name for b in platform_builders if "acceptance" in b.name
]
master_acceptance = Dependent(name="%s-master-acceptance" % platform,
upstream=master_unit,
builderNames=acceptance_builders)
schedulers.extend([master_unit, master_acceptance])
return schedulers
def Update(_config, active_master, c):
c['schedulers'].extend([
SingleBranchScheduler(name='linux_src',
branch='master',
treeStableTimer=60,
builderNames=[
'Linux Builder',
'Linux Builder (dbg)(32)',
'Linux Builder (dbg)',
'Cast Linux',
'Cast Audio Linux',
'Deterministic Linux',
]),
])
# name (str): required, must match string in schedulers above
# recipe (str): optional (default: 'chromium'), the recipe to use for
# this builder.
specs = [
{
'name': 'Linux Builder'
},
{
'name': 'Linux Tests'
},
{
'name': 'Linux Builder (dbg)(32)'
},
{
'name': 'Linux Tests (dbg)(1)(32)'
},
{
'name': 'Linux Builder (dbg)'
},
{
'name': 'Linux Tests (dbg)(1)'
},
{
'name': 'Cast Linux'
},
{
'name': 'Cast Audio Linux'
},
{
'name': 'Deterministic Linux',
'recipe': 'swarming/deterministic_build'
},
]
c['builders'].extend([{
'name':
spec['name'],
'factory':
m_remote_run(spec.get('recipe', 'chromium')),
'notify_on_missing':
True,
'category':
'4linux',
} for spec in specs])
def Update(c):
c['schedulers'].extend([
SingleBranchScheduler(name='libyuv_windows_scheduler',
branch='master',
treeStableTimer=0,
builderNames=[
'Win32 Debug',
'Win32 Release',
'Win64 Debug',
'Win64 Release',
'Win32 Debug (Clang)',
'Win32 Release (Clang)',
'Win64 Debug (Clang)',
'Win64 Release (Clang)',
]),
])
specs = [
{
'name': 'Win32 Debug',
'slavebuilddir': 'win'
},
{
'name': 'Win32 Release',
'slavebuilddir': 'win'
},
{
'name': 'Win64 Debug',
'slavebuilddir': 'win'
},
{
'name': 'Win64 Release',
'slavebuilddir': 'win'
},
{
'name': 'Win32 Debug (Clang)',
'slavebuilddir': 'win_clang'
},
{
'name': 'Win32 Release (Clang)',
'slavebuilddir': 'win_clang'
},
{
'name': 'Win64 Debug (Clang)',
'slavebuilddir': 'win_clang'
},
{
'name': 'Win64 Release (Clang)',
'slavebuilddir': 'win_clang'
},
]
c['builders'].extend([{
'name': spec['name'],
'factory': m_annotator.BaseFactory('libyuv/libyuv'),
'notify_on_missing': True,
'category': 'win',
'slavebuilddir': spec['slavebuilddir'],
} for spec in specs])
def get_schedulers(build):
quick = SingleBranchScheduler(name='quick',
branch='master',
treeStableTimer=60,
builderNames=["12.04-" + build])
sprint = SingleBranchScheduler(name='sprint',
branch='sprint',
treeStableTimer=60,
builderNames=["12.04-" + build + '_sprint'])
try_job = Try_Jobdir(name="try_job",
builderNames=["12.04-" + build + '_try'],
jobdir="jobdir")
return [quick, sprint, try_job]
def Update(config, active_master, c):
c['schedulers'].extend([
SingleBranchScheduler(name='mac_src',
branch='master',
treeStableTimer=60,
builderNames=[
'Mac Builder',
'Mac Builder (dbg)',
'Mac GN',
'Mac GN (dbg)',
]),
])
specs = [
{
'name': 'Mac Builder'
},
{
'name': 'Mac10.6 Tests'
},
{
'name': 'Mac10.8 Tests'
},
{
'name': 'Mac10.9 Tests'
},
{
'name': 'Mac10.10 Tests'
},
{
'name': 'Mac10.11 Tests'
},
{
'name': 'Mac Builder (dbg)'
},
{
'name': 'Mac10.9 Tests (dbg)'
},
{
'name': 'Mac GN'
},
{
'name': 'Mac GN (dbg)'
},
]
c['builders'].extend([{
'name':
spec['name'],
'factory':
m_annotator.BaseFactory(
spec.get('recipe', 'chromium'),
factory_properties=spec.get('factory_properties')),
'notify_on_missing':
True,
'category':
'3mac',
} for spec in specs])
def addBuildsetForChanges(self, *args, **kwargs):
kwargs['properties'] = yield self._addBuildIdProperty(
kwargs.get('changeids', ()),
kwargs.get('properties'),
)
rv = yield SingleBranchScheduler.addBuildsetForChanges(
self, *args, **kwargs)
defer.returnValue(rv)
def Update(config, active_master, c):
c['schedulers'].extend([
SingleBranchScheduler(name='chromium_local',
branch='master',
treeStableTimer=60,
builderNames=[
'Linux ChromiumOS Full',
'Linux ChromiumOS Builder',
'Linux ChromiumOS Builder (dbg)',
]),
Triggerable(name='chromiumos_rel_trigger',
builderNames=[
'Linux ChromiumOS Tests (1)',
'Linux ChromiumOS Tests (2)',
]),
Triggerable(name='chromiumos_dbg_trigger',
builderNames=[
'Linux ChromiumOS Tests (dbg)(1)',
'Linux ChromiumOS Tests (dbg)(2)',
'Linux ChromiumOS Tests (dbg)(3)',
]),
])
c['builders'].extend([{
'name':
spec['buildername'],
'factory':
m_annotator.BaseFactory('chromium', triggers=spec.get('triggers')),
'category':
'nonlayout',
} for spec in [
{
'buildername': 'Linux ChromiumOS Full'
},
{
'buildername': 'Linux ChromiumOS Builder',
'triggers': ['chromiumos_rel_trigger']
},
{
'buildername': 'Linux ChromiumOS Tests (1)'
},
{
'buildername': 'Linux ChromiumOS Tests (2)'
},
{
'buildername': 'Linux ChromiumOS Builder (dbg)',
'triggers': ['chromiumos_dbg_trigger']
},
{
'buildername': 'Linux ChromiumOS Tests (dbg)(1)'
},
{
'buildername': 'Linux ChromiumOS Tests (dbg)(2)'
},
{
'buildername': 'Linux ChromiumOS Tests (dbg)(3)'
},
]])
def configure(config):
# pollers
config['change_source'].append(
GitPoller(repositoryUri,
workdir='gitpoller-workdir',
branch='dev',
pollinterval=60,
project='toy-factory-dev'))
# schedulers
config['schedulers'].append(
SingleBranchScheduler(
name="toy-factory-dev-ci",
change_filter=filter.ChangeFilter(branch='dev'),
treeStableTimer=None,
builderNames=["toy-factory-linux-ci", "toy-factory-windows-ci"]))
config['schedulers'].append(
ForceScheduler(
name="toy-factory-dev-ci-force",
builderNames=["toy-factory-linux-ci", "toy-factory-windows-ci"]))
config['schedulers'].append(
Nightly(
name='toy-factory-dev-nightly',
branch='dev',
builderNames=["toy-factory-linux-dev", "toy-factory-windows-dev"],
hour=3,
minute=0,
onlyIfChanged=True))
config['schedulers'].append(
ForceScheduler(
name="toy-factory-dev-force",
builderNames=["toy-factory-linux-dev", "toy-factory-windows-dev"]))
# builders
config['builders'].append(
BuilderConfig(name="toy-factory-linux-ci",
slavenames=["linux"],
factory=createLinuxCIFactory()))
config['builders'].append(
BuilderConfig(name="toy-factory-windows-ci",
slavenames=["windows"],
factory=createWindowsCIFactory()))
config['builders'].append(
BuilderConfig(name="toy-factory-linux-dev",
slavenames=["linux"],
factory=createLinuxDevFactory()))
config['builders'].append(
BuilderConfig(name="toy-factory-windows-dev",
slavenames=["windows"],
factory=createWindowsDevFactory()))
def Update(c):
buildernames_list = [
'Android Builder (dbg)',
'Android GN',
'Android GN (dbg)',
]
c['schedulers'].extend([
SingleBranchScheduler(name='android_webrtc_scheduler',
branch='trunk',
treeStableTimer=0,
builderNames=buildernames_list),
Periodic(name='android_periodic_scheduler',
periodicBuildTimer=30 * 60,
builderNames=buildernames_list),
Triggerable(name='android_trigger_dbg',
builderNames=[
'Android Tests (dbg) (KK Nexus5)',
'Android Tests (dbg) (JB Nexus7.2)',
]),
])
specs = [
{
'name': 'Android Builder (dbg)',
'triggers': ['android_trigger_dbg'],
},
{
'name': 'Android Tests (dbg) (KK Nexus5)'
},
{
'name': 'Android Tests (dbg) (JB Nexus7.2)'
},
{
'name': 'Android GN',
'slavebuilddir': 'android_gn',
},
{
'name': 'Android GN (dbg)',
'slavebuilddir': 'android_gn',
},
]
c['builders'].extend([{
'name':
spec['name'],
'factory':
m_annotator.BaseFactory('webrtc/chromium',
triggers=spec.get('triggers')),
'category':
'android',
'notify_on_missing':
True,
'slavebuilddir':
spec.get('slavebuilddir', 'android'),
} for spec in specs])
def addBuildsetForChanges(self, *args, **kwargs):
kwargs['properties'] = yield self._addBuildIdProperty(
kwargs.get('changeids', ()),
kwargs.get('properties'),
)
rv = yield SingleBranchScheduler.addBuildsetForChanges(
self,
*args,
**kwargs)
defer.returnValue(rv)
def Update(c):
c['schedulers'].extend([
SingleBranchScheduler(name='webrtc_linux_scheduler',
branch='master',
treeStableTimer=0,
builderNames=[
'Linux (swarming)',
'Linux32 Debug (ARM)',
'Linux64 GCC',
]),
# Run WebRTC DEPS roller every 3 hours.
Periodic(
name='webrtc_deps',
periodicBuildTimer=3 * 60 * 60,
branch=None,
builderNames=['Auto-roll - WebRTC DEPS'],
),
])
specs = [
{
'name': 'Linux (swarming)',
'slavebuilddir': 'linux_swarming'
},
{
'name': 'Linux32 Debug (ARM)',
'slavebuilddir': 'linux_arm'
},
{
'name': 'Linux64 GCC',
'slavebuilddir': 'linux_gcc'
},
{
'name': 'Auto-roll - WebRTC DEPS',
'recipe': 'webrtc/auto_roll_webrtc_deps',
'slavebuilddir': 'linux_autoroll',
},
]
c['builders'].extend([{
'name':
spec['name'],
'factory':
m_annotator.BaseFactory(spec['recipe'])
if 'recipe' in spec else m_remote_run('webrtc/standalone'),
'notify_on_missing':
True,
'category':
'linux',
'slavebuilddir':
spec['slavebuilddir'],
'auto_reboot':
False,
} for spec in specs])
def Update(c):
c['schedulers'].extend([
SingleBranchScheduler(name='libyuv_mac_scheduler',
branch='master',
treeStableTimer=0,
builderNames=[
'Mac64 Debug',
'Mac64 Release',
'Mac Asan',
'iOS Debug',
'iOS Release',
'iOS ARM64 Debug',
'iOS ARM64 Release',
]),
])
specs = [
{
'name': 'Mac64 Debug',
'slavebuilddir': 'mac64'
},
{
'name': 'Mac64 Release',
'slavebuilddir': 'mac64'
},
{
'name': 'Mac Asan',
'slavebuilddir': 'mac_asan'
},
{
'name': 'iOS Debug',
'slavebuilddir': 'mac32'
},
{
'name': 'iOS Release',
'slavebuilddir': 'mac32'
},
{
'name': 'iOS ARM64 Debug',
'slavebuilddir': 'mac64'
},
{
'name': 'iOS ARM64 Release',
'slavebuilddir': 'mac64'
},
]
c['builders'].extend([{
'name': spec['name'],
'factory': m_annotator.BaseFactory('libyuv/libyuv'),
'notify_on_missing': True,
'category': 'mac',
'slavebuilddir': spec['slavebuilddir'],
} for spec in specs])
def watch_paths(self, paths):
"""
Start the build if an incoming change-set contains files that begin with the given
directory names.
"""
BuildmasterConfig['schedulers'].append(SingleBranchScheduler(
builderNames=[self.name],
change_filter=ChangeFilter(filter_fn=partial(is_dir_in_change, paths)),
name=scheduler_name(self, 'filter-' + hashify(''.join(paths))),
treeStableTimer=60))
