Websites/perf.webkit.org/public/v2/analysis.js

   1 App.AnalysisTask = App.NameLabelModel.extend({
   2     author: DS.attr('string'),
   3     createdAt: DS.attr('date'),
   4     platform: DS.belongsTo('platform'),
   5     metric: DS.belongsTo('metric'),
   6     startRun: DS.attr('number'),
   7     endRun: DS.attr('number'),
   8     bugs: DS.hasMany('bugs'),
   9     testGroups: function (key, value, oldValue) {
  10         return this.store.find('testGroup', {task: this.get('id')});
  11     }.property(),
  12     triggerable: function () {
  13         return this.store.find('triggerable', {task: this.get('id')}).then(function (triggerables) {
  14             return triggerables.objectAt(0);
  15         }, function () {
  16             return null;
  17         });
  18     }.property(),
  19     label: function () {
  20         var label = this.get('name');
  21         var bugs = this.get('bugs').map(function (bug) { return bug.get('label'); }).join(' / ');
  22         return bugs ? label + ' (' + bugs + ')' : label;
  23     }.property('name', 'bugs'),
  24 });
  25
  26 App.Bug = App.Model.extend({
  27     task: DS.belongsTo('AnalysisTask'),
  28     bugTracker: DS.belongsTo('BugTracker'),
  29     createdAt: DS.attr('date'),
  30     number: DS.attr('number'),
  31     label: function () {
  32         return this.get('bugTracker').get('label') + ': ' + this.get('number');
  33     }.property('name', 'bugTracker'),
  34 });
  35
  36 // FIXME: Use DS.RESTAdapter instead.
  37 App.AnalysisTask.create = function (name, startMeasurement, endMeasurement)
  38 {
  39     return PrivilegedAPI.sendRequest('create-analysis-task', {
  40         name: name,
  41         startRun: startMeasurement.id(),
  42         endRun: endMeasurement.id(),
  43     });
  44 }
  45
  46 App.AnalysisTaskAdapter = DS.RESTAdapter.extend({
  47     buildURL: function (type, id)
  48     {
  49         return '../api/analysis-tasks/' + (id ? id : '');
  50     },
  51 });
  52
  53 App.BugAdapter = DS.RESTAdapter.extend({
  54     createRecord: function (store, type, record)
  55     {
  56         var param = {
  57             task: record.get('task').get('id'),
  58             bugTracker: record.get('bugTracker').get('id'),
  59             number: record.get('number'),
  60         };
  61         return PrivilegedAPI.sendRequest('associate-bug', param).then(function (data) {
  62             param['id'] = data['bugId'];
  63             return {'bug': param};
  64         });
  65     }
  66 });
  67
  68 App.Root = App.Model.extend({
  69     repository: DS.belongsTo('repository'),
  70     revision: DS.attr('string'),
  71 });
  72
  73 App.RootSet = App.Model.extend({
  74     roots: DS.hasMany('roots'),
  75     revisionForRepository: function (repository)
  76     {
  77         var root = this.get('roots').findBy('repository', repository);
  78         if (!root)
  79             return null;
  80         return root.get('revision');
  81     }
  82 });
  83
  84 App.TestGroup = App.NameLabelModel.extend({
  85     task: DS.belongsTo('analysisTask'),
  86     author: DS.attr('string'),
  87     createdAt: DS.attr('date'),
  88     buildRequests: DS.hasMany('buildRequests'),
  89     rootSets: DS.hasMany('rootSets'),
  90     _fetchTestResults: function ()
  91     {
  92         var task = this.get('task');
  93         if (!task)
  94             return null;
  95         var self = this;
  96         return App.Manifest.fetchRunsWithPlatformAndMetric(this.store,
  97             task.get('platform').get('id'), task.get('metric').get('id'), this.get('id')).then(
  98             function (result) { self.set('testResults', result.data); },
  99             function (error) {
 100                 // FIXME: Somehow this never gets called.
 101                 alert('Failed to fetch the results:' + error);
 102                 return null;
 103             });
 104     }.observes('task', 'task.platform', 'task.metric').on('init'),
 105 });
 106
 107 App.TestGroup.create = function (analysisTask, name, rootSets, repetitionCount)
 108 {
 109     var param = {
 110         task: analysisTask.get('id'),
 111         name: name,
 112         rootSets: rootSets,
 113         repetitionCount: repetitionCount,
 114     };
 115     return PrivilegedAPI.sendRequest('create-test-group', param).then(function (data) {
 116         analysisTask.set('testGroups'); // Refetch test groups.
 117         return analysisTask.store.find('testGroup', data['testGroupId']);
 118     });
 119 }
 120
 121 App.TestGroupAdapter = DS.RESTAdapter.extend({
 122     buildURL: function (type, id)
 123     {
 124         return '../api/test-groups/' + (id ? id : '');
 125     },
 126 });
 127
 128 App.Triggerable = App.NameLabelModel.extend({
 129     acceptedRepositories: DS.hasMany('repositories'),
 130 });
 131
 132 App.TriggerableAdapter = DS.RESTAdapter.extend({
 133     buildURL: function (type, id)
 134     {
 135         return '../api/triggerables/' + (id ? id : '');
 136     },
 137 });
 138
 139 App.AnalysisTaskSerializer = App.TestGroupSerializer = App.TriggerableSerializer = DS.RESTSerializer.extend({
 140     normalizePayload: function (payload)
 141     {
 142         delete payload['status'];
 143         return payload;
 144     }
 145 });
 146
 147 App.BuildRequest = App.Model.extend({
 148     testGroup: DS.belongsTo('testGroup'),
 149     order: DS.attr('number'),
 150     orderLabel: function ()
 151     {
 152         return this.get('order') + 1;
 153     }.property('order'),
 154     rootSet: DS.belongsTo('rootSet'),
 155     status: DS.attr('string'),
 156     statusLabel: function ()
 157     {
 158         switch (this.get('status')) {
 159         case 'pending':
 160             return 'Waiting to be scheduled';
 161         case 'scheduled':
 162             return 'Scheduled';
 163         case 'running':
 164             return 'Running';
 165         case 'failed':
 166             return 'Failed';
 167         case 'completed':
 168             return 'Completed';
 169         }
 170     }.property('status'),
 171     url: DS.attr('string'),
 172     build: DS.attr('number'),
 173 });
 174
 175 App.BuildRequest.aggregateStatuses = function (requests)
 176 {
 177     var completeCount = 0;
 178     var failureCount = 0;
 179     requests.forEach(function (request) {
 180         switch (request.get('status')) {
 181         case 'failed':
 182             failureCount++;
 183             break;
 184         case 'completed':
 185             completeCount++;
 186             break;
 187         }
 188     });
 189     if (completeCount == requests.length)
 190         return 'Done';
 191     if (failureCount == requests.length)
 192         return 'All failed';
 193     var status = completeCount + ' out of ' + requests.length + ' completed';
 194     if (failureCount)
 195         status += ', ' + failureCount + ' failed';
 196     return status;
 197 }