def __init__(self, minUptake, configRepo, checkMARs=True,
              username=None, password=None, pollInterval=5 * 60,
              pollTimeout=12 * 60 * 60, **kwargs):
     self.minUptake = minUptake
     self.configRepo = configRepo
     self.checkMARs = checkMARs
     self.username = username
     self.password = password
     self.pollInterval = pollInterval
     self.pollTimeout = pollTimeout
     self.ss = None
     self.set_props = None
     Triggerable.__init__(self, **kwargs)
Beispiel #2
0
 def __init__(self, minUptake, configRepo, checkMARs=True,
              username=None, password=None, pollInterval=5*60,
              pollTimeout=12*60*60, **kwargs):
     self.minUptake = minUptake
     self.configRepo = configRepo
     self.checkMARs = checkMARs
     self.username = username
     self.password = password
     self.pollInterval = pollInterval
     self.pollTimeout = pollTimeout
     self.ss = None
     self.set_props = None
     Triggerable.__init__(self, **kwargs)
    def setup_project_inplace(self, project):
        self.setup_inplace()
        for worker in self.inplace_workers:
            log.msg("Got worker '%s' for platform %s and setups %s" %
                    (worker.name, pformat(
                        worker.platforms), pformat(worker.setups)),
                    system='Inplace Config')
        for profile in project.inplace.profiles:
            worker_names = self.project_profile_worker_names(profile)
            if not worker_names:
                log.msg(
                    "Failed to find worker for platform '%s' and setups '%s' (project '%s')"
                    %
                    (profile.platform, pformat(profile.setups), project.name),
                    system='Inplace Config')
                continue  # profile not executable

            builder_name = "_".join(
                [project.name, profile.platform, profile.name])
            trigger_name = _project_profile_trigger_name(project.name, profile)
            build_factory = SetupBuildFactory(self, project, profile)
            self.builders.named_set(
                BuilderConfig(name=builder_name,
                              workernames=worker_names,
                              factory=build_factory))
            self.schedulers.named_set(
                Triggerable(name=trigger_name, builderNames=[builder_name]))
Beispiel #4
0
    def __init__(self, name, workers):
        super(FreestyleJob, self).__init__(name, workers)

        add_artifact_pre_build_steps(self)

        # Add a "triggerable" build step so that other jobs can trigger us.
        BuildmasterConfig['schedulers'].append(Triggerable(
            name=scheduler_name(self, 'trigger'),
            builderNames=[self.name]))
    def configure(self, config_dict):
        c = self.config = config_dict
        PORT = int(os.environ.get('PORT', 8010))
        c.setdefault(
            'buildbotURL',
            os.environ.get('buildbotURL', "http://localhost:%d/" % (PORT, )))

        db_url = os.environ.get('BUILDBOT_DB_URL')
        if db_url is not None:
            self.config.setdefault('db', {'db_url': db_url})

        # minimalistic config to activate new web UI
        c.setdefault(
            'www',
            dict(
                port=PORT,
                plugins=dict(console_view=True, waterfall_view=True),
            ))
        c.setdefault('protocols', {'pb': {'port': 9989}})
        c.setdefault('builders', [])
        c.setdefault('schedulers', [])

        # Define the builder for the main job
        f = factory.BuildFactory()
        f.addStep(
            Git(repourl=Property("repository"),
                codebase=Property("codebase"),
                name='git',
                shallow=1))
        f.addStep(SpawnerStep())

        self.config['builders'].append(
            BuilderConfig(name='__spawner',
                          workernames=self.get_spawner_workers(),
                          collapseRequests=False,
                          factory=f))
        self.config['schedulers'].append(
            AnyCodeBaseScheduler(name='__spawner', builderNames=['__spawner']))

        # Define the builder for the main job
        f = factory.BuildFactory()
        f.addStep(RunnerStep())

        self.config['builders'].append(
            BuilderConfig(name='__runner',
                          workernames=self.get_runner_workers(),
                          collapseRequests=False,
                          factory=f))
        self.config['schedulers'].append(
            Triggerable(
                name='__runner',
                builderNames=['__runner'],
                codebases={},
            ))
    def _getTrySchedulers(self):
        """
        Create and return try schedulers and their associated triggerable.
        """
        result = []

        configuration = self._raw['try_scheduler']

        try_scheduler = Try_Userpass(
            name='try',
            port=configuration['port'],
            userpass=configuration['credentials'],
            builderNames=self._try_targets,
            properties={},
        )
        result.append(try_scheduler)

        for name in self._try_targets:
            result.append(Triggerable(name=name, builderNames=[name]))

        return result
def getSchedulers():
    schedulers = [
        ForceScheduler(
            name="force-flocker-acceptance",
            codebases=[
                CodebaseParameter(
                    "flocker",
                    branch=StringParameter("branch", default="master",
                                           size=80),
                    repository=FixedParameter("repository",
                                              default=GITHUB + b"/flocker"),
                ),
            ],
            properties=[
                report_expected_failures_parameter,
            ],
            builderNames=BUILDERS,
        ),
    ]
    for distribution in OMNIBUS_DISTRIBUTIONS:
        builders = [
            configuration.builder_name
            for configuration in ACCEPTANCE_CONFIGURATIONS
            if configuration.distribution == distribution
        ]
        schedulers.append(
            Triggerable(
                name='trigger/built-packages/%s' % (distribution, ),
                builderNames=builders,
                codebases={
                    "flocker": {
                        "repository": GITHUB + b"/flocker"
                    },
                },
            ))
    return schedulers
Beispiel #8
0
    def define_travis_builder(self,
                              name,
                              repository,
                              branch=None,
                              vcs_type=None,
                              username=None,
                              password=None):
        job_name = "%s-job" % name
        spawner_name = name

        if not repository.endswith("/"):
            repository = repository + "/"

        if not vcs_type:
            if repository.startswith("https://svn."):
                vcs_type = "svn"
            elif repository.startswith("git://github.com/"):
                vcs_type = "git"

        if not username and not password:
            p = urlparse.urlparse(repository)
            k = (p.scheme, p.netloc)
            if k in self.passwords:
                username, password = self.passwords[k]

        # Define the builder for the main job
        self.config['builders'].append(
            BuilderConfig(
                name=job_name,
                slavenames=self.get_runner_slaves(),
                properties=self.properties,
                #mergeRequests = mergeRequests,
                mergeRequests=False,
                factory=TravisFactory(
                    repository=repository,
                    branch=branch,
                    vcs_type=vcs_type,
                    username=username,
                    password=password,
                ),
            ))

        self.config['schedulers'].append(Triggerable(job_name, [job_name]))

        # Define the builder for a spawer
        self.config['builders'].append(
            BuilderConfig(
                name=spawner_name,
                nextBuild=nextBuild,
                slavenames=self.get_spawner_slaves(),
                properties=self.properties,
                category="spawner",
                factory=TravisSpawnerFactory(
                    repository=repository,
                    branch=branch,
                    scheduler=job_name,
                    vcs_type=vcs_type,
                    username=username,
                    password=password,
                ),
            ))

        SchedulerKlass = {
            True: SingleBranchScheduler,
            False: AnyBranchScheduler
        }[bool(branch)]

        self.config['schedulers'].append(
            SchedulerKlass(
                name=spawner_name,
                builderNames=[spawner_name],
                change_filter=ChangeFilter(project=name),
                onlyImportant=True,
                fileIsImportant=fileIsImportant,
            ))

        setup_poller = dict(git=self.setup_git_poller,
                            svn=self.setup_svn_poller)[vcs_type]
        setup_poller(repository, branch, name, username, password)
Beispiel #9
0
 def checkUptake(self, uptake):
     log.msg('%s: uptake is %s' % (self.__class__.__name__, uptake))
     if uptake >= self.minUptake:
         self.stopLoop('Reached required uptake: %s' % uptake)
         Triggerable.trigger(self, self.ss, self.set_props)
Beispiel #10
0
from buildbot.schedulers.triggerable import Triggerable
from buildbot.changes.filter import ChangeFilter
from buildbot.process.factory import BuildFactory
from buildbot.steps.master import MasterShellCommand
from buildscripts import steps as buildsteps

project = __opts__['project']

c['schedulers'].append(
    AnyBranchScheduler(name=project,
                       change_filter=ChangeFilter(project=project,
                                                  category='default'),
                       builderNames=['{0} source'.format(project)]))

c["schedulers"].append(
    Triggerable(name="{0} packaging".format(project),
                builderNames=["deb_packaging", "rpm_packaging"]))


def push_to_github(__opts__):
    cwd = 'sandboxes/{0}/svn2git'.format(project)
    return [
        MasterShellCommand(command="""
                    cd sandboxes/{0}/svn2git
                    svn2git --rebase --verbose
                    git push origin master""".format(project),
                           description='Pushing commit to GitHub',
                           descriptionDone='Push commit to GitHub (trunk)'),
    ]


c['builders'].append(
Beispiel #11
0
    def define_travis_builder(self, name, repository, tags=None, **kwargs):
        name = str(name)
        repository = str(repository)
        job_name = "%s-job" % name
        try_name = "%s-try" % name
        deploy_name = "%s-deploy" % name
        spawner_name = name
        if tags is None:
            tags = []

        def formatTag(tag):
            if isinstance(tag, string_types):
                return str(tag)
            return str(tag['text'])

        def uniq(tags):
            """tags needs to be unique list, so we need to filter them into a set"""
            return list(set(tags))

        tags = [formatTag(tag) for tag in tags]
        if 'username' not in kwargs and 'password' not in kwargs:
            p = urlparse(repository)
            k = (p.scheme, p.netloc)
            if k in self.passwords:
                kwargs['username'], kwargs['password'] = self.passwords[k]

        codebases = {spawner_name: {'repository': repository}}
        for subrepo in kwargs.get('subrepos', []):
            codebases[subrepo['project']] = {
                'repository': subrepo['repository']
            }

        vcsManager = addRepository(
            name, dict(name=name, repository=repository, **kwargs))
        vcsManager.vardir = self.vardir

        # Define the builder for the main job
        f = factory.BuildFactory()
        vcsManager.addSourceSteps(f)
        f.addStep(TravisSetupSteps())

        self.config['builders'].append(
            BuilderConfig(name=job_name,
                          workernames=self.get_runner_workers(),
                          properties=self.properties,
                          collapseRequests=False,
                          env=self.defaultEnv,
                          tags=uniq(["job", name] + tags),
                          factory=f))

        self.config['schedulers'].append(
            Triggerable(
                name=job_name,
                builderNames=[job_name],
                codebases=codebases,
            ))

        # Define the builder for a spawner
        f = factory.BuildFactory()
        vcsManager.addSourceSteps(f)
        f.addStep(TravisTrigger(scheduler=job_name, ))
        properties = dict(TRAVIS_PULL_REQUEST=False)
        properties.update(self.properties)
        self.config['builders'].append(
            BuilderConfig(name=spawner_name,
                          workernames=self.get_spawner_workers(),
                          properties=properties,
                          tags=uniq(["trunk", name] + tags),
                          factory=f))

        # no need for deployment builder if no stage is configured
        if kwargs.get('stages', []):
            # Define the builder for the deployment of the project
            f = factory.BuildFactory()
            vcsManager.addSourceSteps(f)
            f.addStep(TravisSetupSteps())

            # To manage deployment properly (with change traceability),
            # we need the version and the target deployment environment or "stage"
            version = StringParameter(name='version',
                                      label='GIT tag',
                                      hide=False,
                                      required=False,
                                      size=20)
            stage = StringParameter(name='stage',
                                    label='Stage',
                                    hide=False,
                                    required=False,
                                    size=20)

            dep_properties = [version, stage]

            self.config['builders'].append(
                BuilderConfig(name=deploy_name,
                              workernames=self.get_runner_workers(),
                              env=self.defaultEnv,
                              tags=uniq(["deploy", name] + tags),
                              factory=f))
        else:
            dep_properties = []
        if vcsManager.supportsTry:
            properties = dict(TRAVIS_PULL_REQUEST=True)
            properties.update(self.properties)
            # Define the builder for try job
            f = factory.BuildFactory()
            vcsManager.addSourceSteps(f)
            f.addStep(TravisTrigger(scheduler=job_name, ))

            self.config['builders'].append(
                BuilderConfig(name=try_name,
                              workernames=self.get_spawner_workers(),
                              properties=properties,
                              tags=uniq(["try", name] + tags),
                              factory=f))

        vcsManager.setupSchedulers(self.config['schedulers'], spawner_name,
                                   try_name, deploy_name,
                                   self.importantManager, codebases,
                                   dep_properties)
        vcsManager.setupReporters(self.config['services'], spawner_name,
                                  try_name, codebases)
        res = vcsManager.setupChangeSource(self.config['services'])
        if res is not None:
            self.change_hook_dialects.update(res)
Beispiel #12
0
 "change_source": [
     PBChangeSource(user="******", passwd=CHANGESOURCE_PASSWORD),
 ],
 "schedulers": [
     win64_release,
     win64_debug,
     osx_release,
     deb64_release,
     ubu64_release,
     android_release,
     freebsd_release,
     Triggerable(name="fifoci-lin",
                 builderNames=[
                     "fifoci-ogl-lin-intel",
                     "fifoci-ogl-lin-mesa",
                     "fifoci-ogl-lin-nouveau",
                     "fifoci-ogl-lin-nv",
                     "fifoci-ogl-lin-radeon",
                     "fifoci-sw-lin-mesa",
                 ]),
     Triggerable(name="fifoci-win", builderNames=[
         "fifoci-dx-win-nv",
     ]),
     Triggerable(name="pr-fifoci-lin",
                 builderNames=[
                     "pr-fifoci-ogl-lin-intel",
                     "pr-fifoci-ogl-lin-mesa",
                     "pr-fifoci-ogl-lin-nouveau",
                     "pr-fifoci-ogl-lin-nv",
                     "pr-fifoci-ogl-lin-radeon",
                     "pr-fifoci-sw-lin-mesa",
Beispiel #13
0
                                  codebases=all_serpent_codebases,
                                  treeStableTimer=60,
                                  builderNames=[
                                      "Linux Serpent %s" % branch,
                                      "OSX Serpent %s" % branch
                                  ]),

            # Brew triggerables
            # Triggerable(
            #     name="cpp-ethereum-%s-brew" % branch,
            #     builderNames=[
            #         "OSX C++ %s brew" % branch,
            #         "OSX C++ GUI %s brew" % branch],
            #     codebases=all_cpp_ethereum_codebases),
            Triggerable(name="go-ethereum-%s-yosemite" % branch,
                        builderNames=["OSX Go %s Yosemite" % branch],
                        codebases=all_go_ethereum_codebases),
            Triggerable(name="go-ethereum-%s-el-capitan" % branch,
                        builderNames=["OSX Go %s El Capitan" % branch],
                        codebases=all_go_ethereum_codebases),

            # Extra triggerable checks
            # Triggerable(
            #     name="cpp-ethereum-%s-check" % branch,
            #     builderNames=["Linux C++ %s check" % branch],
            #     codebases=all_cpp_ethereum_codebases),
            # Triggerable(
            #     name="cpp-ethereum-%s-osx-check" % branch,
            #     builderNames=["OSX C++ %s check" % branch],
            #     codebases=all_cpp_ethereum_codebases),
Beispiel #14
0
def triggerable_scheduler(scheduler_name, builder_name):
    return Triggerable(name=scheduler_name, builderNames=[builder_name])
Beispiel #15
0
            #"CMake-Debian-6.0-x64", # TODO try to lower the requirement to cmake 2.8.2
            "Debian-6.0-x64",
            "CMake-Cygwin",
            "Cygwin",
            "CMake-Windows-MinGW",
            "CMake-Windows-MSYS",
            "CMake-Windows-NMake-VS10",
            "CMake-Windows-VS10",
            "Windows-VS10",
            "CMake-Windows-NMake-VS10-x64",
            "CMake-Windows-VS10-x64",
        ],
        fileIsImportant=ea_should_build,
        onlyImportant=True))
c['schedulers'].append(
    Triggerable(name="test-Ubuntu-12.04-x64-scheduler",
                builderNames=["test-Ubuntu-12.04-x64"]))
#c['schedulers'].append(AnyBranchScheduler(
#	name = "test-scheduler",
#	treeStableTimer = None,
#	builderNames = [
#		"test-Ubuntu-12.04-x64",
#		]))
c['schedulers'].append(
    Try_Userpass(name="try-scheduler",
                 builderNames=["Ubuntu-12.04-x64"],
                 port=8031,
                 userpass=[("%%TRY-USERNAME%%", "%%TRY-PASSWORD%%")]))

####### BUILDERS

# The 'builders' list defines the Builders, which tell Buildbot how to perform a build:
 def __init__(self, projects, maxChange=100, **kwargs):
     Triggerable.__init__(self, **kwargs)
     self.projects = projects
     self.lastRevision = None
     self.maxChange = maxChange
 def checkUptake(self, uptake):
     log.msg('%s: uptake is %s' % (self.__class__.__name__, uptake))
     if uptake >= self.minUptake:
         self.stopLoop('Reached required uptake: %s' % uptake)
         Triggerable.trigger(self, self.ss, self.set_props)
Beispiel #18
0
    def define_travis_builder(self, name, repository, branch=None, vcs_type=None, username=None, password=None, subrepos=None):
        job_name = "%s-job" % name
        spawner_name = name

        if not repository.endswith("/"):
            repository = repository + "/"

        if not username and not password:
            p = urlparse.urlparse(repository)
            k = (p.scheme, p.netloc)
            if k in self.passwords:
                username, password = self.passwords[k]

        codebases = {spawner_name: {'repository': repository}}
        if subrepos:
            for subrepo in subrepos:
                codebases[subrepo['project']] = {'repository': subrepo['repository']}

        # Define the builder for the main job
        self.config['builders'].append(BuilderConfig(
            name = job_name,
            slavenames = self.get_runner_slaves(),
            properties = self.properties,
            #mergeRequests = mergeRequests,
            mergeRequests = False,
            env = dict(
                DEBIAN_FRONTEND = "noninteractive",
                CI = "true",
                TRAVIS = "true",
                HAS_JOSH_K_SEAL_OF_APPROVAL = "true",
                LANG = "en_GB.UTF-8",
                LC_ALL = "en_GB.UTF-8",
                ),
            factory = TravisFactory(
                projectname = spawner_name,
                repository = repository,
                branch = branch,
                vcs_type = vcs_type,
                username = username,
                password = password,
                subrepos = subrepos,
                ),
             ))

        self.config['schedulers'].append(Triggerable(
            name=job_name, 
            builderNames=[job_name],
            codebases=codebases,
            ))


        # Define the builder for a spawer
        self.config['builders'].append(BuilderConfig(
            name = spawner_name,
            nextBuild = nextBuild,
            slavenames = self.get_spawner_slaves(),
            properties = self.properties,
            category = "spawner",
            factory = TravisSpawnerFactory(
                projectname = spawner_name,
                repository = repository,
                branch = branch,
                scheduler = job_name,
                vcs_type = vcs_type,
                username = username,
                password = password,
                ),
            ))

        SchedulerKlass = {True:SingleBranchScheduler, False:AnyBranchScheduler}[bool(branch)]

        self.config['schedulers'].append(SchedulerKlass(
            name = spawner_name,
            builderNames = [spawner_name],
            change_filter = ChangeFilter(project=name),
            onlyImportant = True,
            fileIsImportant = fileIsImportant,
            codebases=codebases,
            ))

        self.setup_poller(repository, vcs_type, branch, name, username, password)