Python base.BuildRequest类代码示例

    def command_BUILD(self, args, who):
        args = shlex.split(args)
        repos = { 'apiextractor' : None,
                  'generatorrunner' : None,
                  'shiboken' : None,
                  'pyside' : None
                }

        if not who in config.gitCustomers:
            self.send('%s, I\'ll not make this build for you. Do you think I found my genitalia in the trash?' % who)
            return

        builder = None
        for arg in args:
            try:
                repo, target = arg.split('=')
            except:
                self.send('Usage: ' + PySideContact.command_BUILD.usage)
                return
            if repo == 'builder':
                builder = target
            else:
                if not repo in repos:
                    self.send('%s, there\'s no "%s" repository' % (who, repo))
                    return
                repos[repo] = target

        slaves = ['build-pyside-' + arch for arch in config.slavesByArch.keys()]

        if builder:
            if builder not in slaves:
                self.send("%s, the slave '%s' that you asked for doesn't exist." % (who, builder))
                return
            slaves = [builder]

        for which in slaves:
            bc = self.getControl(which)

            build_properties = Properties()
            build_properties.setProperty('owner', who, 'Build requested from IRC bot on behalf of %s.' % who)
            for propName, propValue in [(pName, pValue) for pName, pValue in repos.items() if pValue]:
                build_properties.setProperty(propName + '_hashtag', propValue, 'Build requested from IRC bot.')

            for repoName, gitUrl in config.gitCustomers[who].items():
                build_properties.setProperty(repoName.lower() + '_gitUrl', config.baseGitURL + gitUrl,
                                             'Personal %s repository of %s.' % (repoName, who))

            r = "forced: by %s: %s" % (self.describeUser(who), 'He had his reasons.')
            s = SourceStamp(branch='BRANCH', revision='REVISION')
            req = BuildRequest(r, s, which, properties=build_properties)
            try:
                bc.requestBuildSoon(req)
            except interfaces.NoSlaveError:
                self.send("%s, sorry, I can't force a build: all slaves are offline" % who)
                return
            ireq = IrcBuildRequest(self)
            req.subscribe(ireq.started)

 def submitBuild(self):
     ss = SourceStamp()
     br = BuildRequest("forced build", ss, "dummy")
     self.control.getBuilder("dummy").requestBuild(br)
     d = defer.Deferred()
     def _started(bc):
         br.unsubscribe(_started)
         d.callback(bc)
     br.subscribe(_started)
     return d

 def requestBuild(self, builder, locale):
     # returns a Deferred that fires with an IBuildStatus object when the
     # build is finished
     props = Properties()
     props.setProperty('locale', locale, 'scheduler')
     props.setProperty('tree', 'app', 'scheduler')
     req = BuildRequest("forced build", SourceStamp(), builder,
                        properties=props)
     self.control.getBuilder(builder).requestBuild(req)
     return req.waitUntilFinished()

 def doBuild(self, buildername, reason="forced"):
     # we need to prevent these builds from being merged, so we create
     # each of them with a different revision specifier. The revision is
     # ignored because our build process does not have a source checkout
     # step.
     self.revision += 1
     br = BuildRequest(reason, SourceStamp(revision=self.revision))
     d = br.waitUntilFinished()
     self.control.getBuilder(buildername).requestBuild(br)
     return d

 def send(res):
     # send some build requests
     ss = SourceStamp()
     for i in range(5):
         req = BuildRequest(str(i), ss, "dummy")
         self.master.botmaster.builders['dummy'].submitBuildRequest(req)
         req.submittedAt = i
         def append(build):
             start_order.append(int(build.reason))
         req.subscribe(append)
         reqs.append(req.waitUntilFinished())

        def _send(res):
            # send some build requests
            reqs = []
            ss = SourceStamp()
            for i in range(5):
                req = BuildRequest(str(i), ss, "dummy")
                self.master.botmaster.builders['dummy'].submitBuildRequest(req)
                reqs.append(req.waitUntilFinished())

            dl = defer.DeferredList(reqs)
            dl.addCallback(check)
            return dl

    def testPriority(self):
        self.rmtree("basedir")
        os.mkdir("basedir")
        self.master.loadConfig(config_priority)
        self.master.readConfig = True
        self.master.startService()

        # Our fake source stamp
        # we override canBeMergedWith so that our requests don't get merged together
        ss = SourceStamp()
        ss.canBeMergedWith = lambda x: False

        # Send 10 requests to alternating builders
        # We fudge the submittedAt field after submitting since they're all
        # getting submitted so close together according to time.time()
        # and all we care about is what order they're run in.
        reqs = []
        self.start_order = []
        for i in range(10):
            req = BuildRequest(str(i), ss, "test_builder")
            j = i % 2 + 1
            self.master.botmaster.builders['quick%i' % j].submitBuildRequest(req)
            req.submittedAt = i
            # Keep track of what order the builds start in
            def append(build):
                self.start_order.append(int(build.reason))
            req.subscribe(append)
            reqs.append(req.waitUntilFinished())

        dl = defer.DeferredList(reqs)
        dl.addCallback(self._all_finished)

        def _delay(res):
            d1 = defer.Deferred()
            reactor.callLater(0.5, d1.callback, None)
            # this test depends upon this 0.5s delay landing us in the middle
            # of one of the builds.
            return d1

        def _connect(res, i):
            return self.connectSlave(slavename="bot%i" % i, builders=["quick1", "quick2"])

        # Now add the slaves
        d = self.connectSlave(slavename="bot0", builders=["quick1", "quick2"])
        for i in range(1,5):
            d.addCallback(_delay)
            d.addCallback(_connect, i)

        d.addCallback(lambda x: dl)

        return d

 def testDontClaimPingingSlave(self):
     # have two slaves connect for the same builder. Do something to the
     # first one so that slavepings are delayed (but do not fail
     # outright).
     timers = []
     self.slaves['bot1'].debugOpts["stallPings"] = (10, timers)
     br = BuildRequest("forced", SourceStamp(), 'test_builder')
     d1 = br.waitUntilFinished()
     self.master.botmaster.builders["b1"].CHOOSE_SLAVES_RANDOMLY = False
     self.control.getBuilder("b1").requestBuild(br)
     s1 = br.status # this is a BuildRequestStatus
     # give it a chance to start pinging
     d2 = defer.Deferred()
     d2.addCallback(self._testDontClaimPingingSlave_1, d1, s1, timers)
     reactor.callLater(1, d2.callback, None)
     return d2

    def _testSlave_1(self, res, t1):
        self.failUnlessEqual(len(t1.events), 2)
        self.failUnlessEqual(t1.events[0],
                             ("builderChangedState", "dummy", "idle"))
        self.failUnlessEqual(t1.events[1],
                             ("builderChangedState", "testdummy", "idle"))
        t1.events = []

        c = interfaces.IControl(self.master)
        req = BuildRequest("forced build for testing", SourceStamp())
        c.getBuilder("dummy").requestBuild(req)
        d = req.waitUntilFinished()
        d2 = self.master.botmaster.waitUntilBuilderIdle("dummy")
        dl = defer.DeferredList([d, d2])
        dl.addCallback(self._testSlave_2)
        return dl

    def _connected(self, *args):
        # Our fake source stamp
        # we override canBeMergedWith so that our requests don't get merged together
        ss = SourceStamp()
        ss.canBeMergedWith = lambda x: False

        # Send one request to tie up the slave before sending future requests
        req0 = BuildRequest("reason", ss, "test_builder")
        self.master.botmaster.builders['quick1'].submitBuildRequest(req0)

        # Send 10 requests to alternating builders
        # We fudge the submittedAt field after submitting since they're all
        # getting submitted so close together according to time.time()
        # and all we care about is what order they're run in.
        reqs = []
        self.finish_order = []
        for i in range(10):
            req = BuildRequest(str(i), ss, "test_builder")
            j = i % 2 + 1
            self.master.botmaster.builders['quick%i' % j].submitBuildRequest(req)
            req.submittedAt = i
            # Keep track of what order the builds finished in
            def append(item, arg):
                self.finish_order.append(item)
            req.waitUntilFinished().addCallback(append, req)
            reqs.append(req.waitUntilFinished())

        dl = defer.DeferredList(reqs)
        dl.addCallback(self._all_finished)

        # After our first build finishes, we should wait for the rest to finish
        d = req0.waitUntilFinished()
        d.addCallback(lambda x: dl)
        return d

 def doBuild(self):
     br = BuildRequest("forced", SourceStamp(), 'test_builder')
     d = br.waitUntilFinished()
     self.control.getBuilder('b1').requestBuild(br)
     return d

    def _testSlave_2(self, res):
        # t1 subscribes to builds, but not anything lower-level
        ev = self.t1.events
        self.failUnlessEqual(len(ev), 4)
        self.failUnlessEqual(ev[0][0:3],
                             ("builderChangedState", "dummy", "building"))
        self.failUnlessEqual(ev[1][0], "buildStarted")
        self.failUnlessEqual(ev[2][0:2]+ev[2][3:4],
                             ("buildFinished", "dummy", builder.SUCCESS))
        self.failUnlessEqual(ev[3][0:3],
                             ("builderChangedState", "dummy", "idle"))

        self.failUnlessEqual([ev[0] for ev in self.t3.events],
                             ["builderAdded",
                              "builderChangedState", # offline
                              "builderAdded",
                              "builderChangedState", # idle
                              "builderChangedState", # offline
                              "builderChangedState", # idle
                              "builderChangedState", # building
                              "buildStarted",
                              "stepStarted", "stepETAUpdate", "stepFinished",
                              "stepStarted", "stepETAUpdate",
                              "logStarted", "logFinished", "stepFinished",
                              "buildFinished",
                              "builderChangedState", # idle
                              ])

        b = self.s1.getLastFinishedBuild()
        self.failUnless(b)
        self.failUnlessEqual(b.getBuilder().getName(), "dummy")
        self.failUnlessEqual(b.getNumber(), 0)
        self.failUnlessEqual(b.getSourceStamp().branch, None)
        self.failUnlessEqual(b.getSourceStamp().patch, None)
        self.failUnlessEqual(b.getSourceStamp().revision, None)
        self.failUnlessEqual(b.getReason(), "forced build for testing")
        self.failUnlessEqual(b.getChanges(), ())
        self.failUnlessEqual(b.getResponsibleUsers(), [])
        self.failUnless(b.isFinished())
        self.failUnlessEqual(b.getText(), ['build', 'successful'])
        self.failUnlessEqual(b.getColor(), "green")
        self.failUnlessEqual(b.getResults(), builder.SUCCESS)

        steps = b.getSteps()
        self.failUnlessEqual(len(steps), 2)

        eta = 0
        st1 = steps[0]
        self.failUnlessEqual(st1.getName(), "dummy")
        self.failUnless(st1.isFinished())
        self.failUnlessEqual(st1.getText(), ["delay", "1 secs"])
        start,finish = st1.getTimes()
        self.failUnless(0.5 < (finish-start) < 10)
        self.failUnlessEqual(st1.getExpectations(), [])
        self.failUnlessEqual(st1.getLogs(), [])
        eta += finish-start

        st2 = steps[1]
        self.failUnlessEqual(st2.getName(), "remote dummy")
        self.failUnless(st2.isFinished())
        self.failUnlessEqual(st2.getText(),
                             ["remote", "delay", "2 secs"])
        start,finish = st2.getTimes()
        self.failUnless(1.5 < (finish-start) < 10)
        eta += finish-start
        self.failUnlessEqual(st2.getExpectations(), [('output', 38, None)])
        logs = st2.getLogs()
        self.failUnlessEqual(len(logs), 1)
        self.failUnlessEqual(logs[0].getName(), "stdio")
        self.failUnlessEqual(logs[0].getText(), "data")

        self.eta = eta
        # now we run it a second time, and we should have an ETA

        self.t4 = t4 = STarget(["builder", "build", "eta"])
        self.master.getStatus().subscribe(t4)
        c = interfaces.IControl(self.master)
        req = BuildRequest("forced build for testing", SourceStamp())
        c.getBuilder("dummy").requestBuild(req)
        d = req.waitUntilFinished()
        d2 = self.master.botmaster.waitUntilBuilderIdle("dummy")
        dl = defer.DeferredList([d, d2])
        dl.addCallback(self._testSlave_3)
        return dl