| /* |
| * Copyright (C) 2013 Apple Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, |
| * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS |
| * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF |
| * THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| BuildbotQueue = function(buildbot, id, info) |
| { |
| BaseObject.call(this); |
| |
| console.assert(buildbot); |
| console.assert(id); |
| |
| this.buildbot = buildbot; |
| this.id = id; |
| |
| // FIXME: Some of these are presentation only, and should be handled above BuildbotQueue level. |
| this.branches = info.branches; |
| this.platform = info.platform.name; |
| this.debug = info.debug; |
| this.builder = info.builder; |
| this.tester = info.tester; |
| this.performance = info.performance; |
| this.staticAnalyzer = info.staticAnalyzer; |
| this.leaks = info.leaks; |
| this.architecture = info.architecture; |
| this.testCategory = info.testCategory; |
| this.heading = info.heading; |
| this.crashesOnly = info.crashesOnly; |
| |
| this.iterations = []; |
| this._knownIterations = {}; |
| |
| // Some queues process changes out of order, but we need to display results for the latest commit, |
| // not the latest build. BuildbotQueue ensures that at least one productive iteration |
| // that was run in order gets loaded (if the queue had any productive iterations, of course). |
| this._hasLoadedIterationForInOrderResult = false; |
| }; |
| |
| BaseObject.addConstructorFunctions(BuildbotQueue); |
| |
| BuildbotQueue.RecentIterationsToLoad = 10; |
| |
| BuildbotQueue.Event = { |
| IterationsAdded: "iterations-added", |
| UnauthorizedAccess: "unauthorized-access" |
| }; |
| |
| BuildbotQueue.prototype = { |
| constructor: BuildbotQueue, |
| __proto__: BaseObject.prototype, |
| |
| get baseURL() |
| { |
| if (this.buildbot.VERSION_LESS_THAN_09) |
| return this.buildbot.baseURL + "json/builders/" + encodeURIComponent(this.id); |
| |
| return this.buildbot.baseURL + "api/v2/builders/" + encodeURIComponent(this.id); |
| }, |
| |
| get allIterationsURL() |
| { |
| if (this.buildbot.VERSION_LESS_THAN_09) |
| return this.baseURL + "/builds/_all/?max=10000"; |
| |
| return this.baseURL + "/builds?order=-number"; |
| }, |
| |
| get buildsURL() |
| { |
| // We need to limit the number of builds for which we fetch the info, as it would |
| // impact performance. For each build, we will be subsequently making REST API calls |
| // to fetch detailed build info. |
| return this.baseURL + "/builds?order=-number&limit=20"; |
| }, |
| |
| get overviewURL() |
| { |
| if (this.buildbot.VERSION_LESS_THAN_09) |
| return this.buildbot.baseURL + "builders/" + encodeURIComponent(this.id) + "?numbuilds=50"; |
| |
| return this.buildbot.baseURL + "#/builders/" + encodeURIComponent(this.id) + "?numbuilds=50"; |
| }, |
| |
| get recentFailedIterationCount() |
| { |
| var firstFinishedIteration = this.mostRecentFinishedIteration; |
| var mostRecentSuccessfulIteration = this.mostRecentSuccessfulIteration; |
| return this.iterations.indexOf(mostRecentSuccessfulIteration) - this.iterations.indexOf(firstFinishedIteration); |
| }, |
| |
| get firstRecentUnsuccessfulIteration() |
| { |
| if (!this.iterations.length) |
| return null; |
| |
| for (var i = 0; i < this.iterations.length; ++i) { |
| if (!this.iterations[i].finished || !this.iterations[i].successful) |
| continue; |
| if (this.iterations[i - 1] && this.iterations[i - 1].finished && !this.iterations[i - 1].successful) |
| return this.iterations[i - 1]; |
| return null; |
| } |
| |
| if (!this.iterations[this.iterations.length - 1].successful) |
| return this.iterations[this.iterations.length - 1]; |
| |
| return null; |
| }, |
| |
| get mostRecentFinishedIteration() |
| { |
| for (var i = 0; i < this.iterations.length; ++i) { |
| if (!this.iterations[i].finished) |
| continue; |
| return this.iterations[i]; |
| } |
| |
| return null; |
| }, |
| |
| get mostRecentSuccessfulIteration() |
| { |
| for (var i = 0; i < this.iterations.length; ++i) { |
| if (!this.iterations[i].finished || !this.iterations[i].successful) |
| continue; |
| return this.iterations[i]; |
| } |
| |
| return null; |
| }, |
| |
| _load: function(url, callback) |
| { |
| if (this.buildbot.needsAuthentication && this.buildbot.authenticationStatus === Buildbot.AuthenticationStatus.InvalidCredentials) |
| return; |
| |
| JSON.load( |
| url, |
| function(data) { |
| this.buildbot.isAuthenticated = true; |
| callback(data); |
| }.bind(this), |
| function(data) { |
| if (data.errorType !== JSON.LoadError || data.errorHTTPCode !== 401) |
| return; |
| if (this.buildbot.isAuthenticated) { |
| // FIXME (128006): Safari/WebKit should coalesce authentication requests with the same origin and authentication realm. |
| // In absence of the fix, Safari presents additional authentication dialogs regardless of whether an earlier authentication |
| // dialog was dismissed. As a way to ameliorate the user experience where a person authenticated successfully using an |
| // earlier authentication dialog and cancelled the authentication dialog associated with the load for this queue, we call |
| // ourself so that we can schedule another load, which should complete successfully now that we have credentials. |
| this._load(url, callback); |
| return; |
| } |
| |
| this.buildbot.isAuthenticated = false; |
| this.dispatchEventToListeners(BuildbotQueue.Event.UnauthorizedAccess, { }); |
| }.bind(this), |
| {withCredentials: this.buildbot.needsAuthentication} |
| ); |
| }, |
| |
| loadMoreHistoricalIterations: function() |
| { |
| var indexOfFirstNewlyLoadingIteration; |
| for (var i = 0; i < this.iterations.length; ++i) { |
| if (indexOfFirstNewlyLoadingIteration !== undefined && i >= indexOfFirstNewlyLoadingIteration + BuildbotQueue.RecentIterationsToLoad) |
| return; |
| var iteration = this.iterations[i]; |
| if (!iteration.finished) |
| continue; |
| if (iteration.isLoading) { |
| // Caller lacks visibility into loading, so it is likely to call this function too often. |
| // Give it a chance to analyze everything that's been already requested first, and then it can decide whether it needs more. |
| return; |
| } |
| if (iteration.loaded && indexOfFirstNewlyLoadingIteration !== undefined) { |
| // There was a gap between loaded iterations, which we've closed now. |
| return; |
| } |
| if (!iteration.loaded) { |
| if (indexOfFirstNewlyLoadingIteration === undefined) |
| indexOfFirstNewlyLoadingIteration = i; |
| if (!this._hasLoadedIterationForInOrderResult) |
| iteration.addEventListener(BuildbotIteration.Event.Updated, this._checkForInOrderResult.bind(this)); |
| iteration.update(); |
| } |
| } |
| }, |
| |
| get buildsInfoURL() |
| { |
| if (this.buildbot.VERSION_LESS_THAN_09) |
| return this.baseURL; |
| |
| return this.buildsURL; |
| }, |
| |
| getBuilds: function(data) |
| { |
| if (this.buildbot.VERSION_LESS_THAN_09) |
| return data.cachedBuilds.reverse(); |
| |
| return data.builds; |
| }, |
| |
| isBuildComplete: function(data, index) |
| { |
| if (this.buildbot.VERSION_LESS_THAN_09) { |
| var currentBuilds = {}; |
| if (data.currentBuilds instanceof Array) |
| data.currentBuilds.forEach(function(id) { currentBuilds[id] = true; }); |
| |
| return (!(data.cachedBuilds[index] in currentBuilds)); |
| } |
| |
| return data.builds[index].complete; |
| }, |
| |
| getIterationID: function(data, index) |
| { |
| if (this.buildbot.VERSION_LESS_THAN_09) |
| return data.cachedBuilds[index]; |
| |
| return data.builds[index].number; |
| }, |
| |
| update: function() |
| { |
| this._load(this.buildsInfoURL, function(data) { |
| var builds = this.getBuilds(data); |
| if (!(builds instanceof Array)) |
| return; |
| |
| var newIterations = []; |
| |
| for (var i = 0; i < builds.length; ++i) { |
| var iterationID = this.getIterationID(data, i); |
| var iteration = this._knownIterations[iterationID]; |
| if (!iteration) { |
| iteration = new BuildbotIteration(this, iterationID, this.isBuildComplete(data, i)); |
| newIterations.push(iteration); |
| this.iterations.push(iteration); |
| this._knownIterations[iteration.id] = iteration; |
| } |
| |
| if (i < BuildbotQueue.RecentIterationsToLoad && (!iteration.finished || !iteration.loaded)) { |
| if (!this._hasLoadedIterationForInOrderResult) |
| iteration.addEventListener(BuildbotIteration.Event.Updated, this._checkForInOrderResult.bind(this)); |
| iteration.update(); |
| } |
| } |
| |
| if (!newIterations.length) |
| return; |
| |
| this.sortIterations(); |
| |
| this.dispatchEventToListeners(BuildbotQueue.Event.IterationsAdded, {addedIterations: newIterations}); |
| }.bind(this)); |
| }, |
| |
| _checkForInOrderResult: function(event) |
| { |
| if (this._hasLoadedIterationForInOrderResult) |
| return; |
| var iterationsInOriginalOrder = this.iterations.concat().sort(function(a, b) { return b.id - a.id; }); |
| for (var i = 0; i < iterationsInOriginalOrder.length - 1; ++i) { |
| var i1 = iterationsInOriginalOrder[i]; |
| var i2 = iterationsInOriginalOrder[i + 1]; |
| if (i1.productive && i2.loaded && this.compareIterationsByRevisions(i1, i2) < 0) { |
| this._hasLoadedIterationForInOrderResult = true; |
| return; |
| } |
| } |
| this.loadMoreHistoricalIterations(); |
| }, |
| |
| loadAll: function(callback) |
| { |
| // FIXME: Don't load everything at once, do it incrementally as requested. |
| this._load(this.allIterationsURL, function(data) { |
| for (var idString in data) { |
| console.assert(typeof idString === "string"); |
| var iteration = new BuildbotIteration(this, data[idString]); |
| this.iterations.push(iteration); |
| this._knownIterations[iteration.id] = iteration; |
| } |
| |
| this.sortIterations(); |
| |
| this._hasLoadedIterationForInOrderResult = true; |
| |
| callback(this); |
| }.bind(this)); |
| }, |
| |
| compareIterations: function(a, b) |
| { |
| result = this.compareIterationsByRevisions(a, b); |
| if (result) |
| return result; |
| |
| // A loaded iteration may not have revision numbers if it failed early, before svn steps finished. |
| result = b.loaded - a.loaded; |
| if (result) |
| return result; |
| |
| return b.id - a.id; |
| }, |
| |
| compareIterationsByRevisions: function(a, b) |
| { |
| var sortedRepositories = Dashboard.sortedRepositories; |
| for (var i = 0; i < sortedRepositories.length; ++i) { |
| var repositoryName = sortedRepositories[i].name; |
| var trac = sortedRepositories[i].trac; |
| console.assert(trac); |
| var indexA = trac.indexOfRevision(a.revision[repositoryName]); |
| var indexB = trac.indexOfRevision(b.revision[repositoryName]); |
| if (indexA !== -1 && indexB !== -1) { |
| var result = indexB - indexA; |
| if (result) |
| return result; |
| } |
| } |
| |
| return 0; |
| }, |
| |
| // Re-insert the iteration if its sort order changed (which happens once details about it get loaded). |
| updateIterationPosition: function(iteration) |
| { |
| var oldIndex; |
| var inserted = false; |
| for (var i = 0; i < this.iterations.length; ++i) { |
| if (!inserted && this.compareIterations(this.iterations[i], iteration) > 0) { |
| this.iterations.splice(i, 0, iteration); |
| if (oldIndex !== undefined) |
| break; |
| inserted = true; |
| continue; |
| } |
| if (this.iterations[i] === iteration) { |
| oldIndex = i; |
| if (inserted) |
| break; |
| } |
| } |
| this.iterations.splice(oldIndex, 1); |
| }, |
| |
| sortIterations: function() |
| { |
| this.iterations.sort(this.compareIterations.bind(this)); |
| } |
| }; |
