Back to home page

OSCL-LXR
 
 

     

0001 /*
0002  * Licensed to the Apache Software Foundation (ASF) under one or more
0003  * contributor license agreements.  See the NOTICE file distributed with
0004  * this work for additional information regarding copyright ownership.
0005  * The ASF licenses this file to You under the Apache License, Version 2.0
0006  * (the "License"); you may not use this file except in compliance with
0007  * the License.  You may obtain a copy of the License at
0008  *
0009  *    http://www.apache.org/licenses/LICENSE-2.0
0010  *
0011  * Unless required by applicable law or agreed to in writing, software
0012  * distributed under the License is distributed on an "AS IS" BASIS,
0013  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
0014  * See the License for the specific language governing permissions and
0015  * limitations under the License.
0016  */
0017 
0018 var threadDumpEnabled = false;
0019 
0020 function setThreadDumpEnabled(val) {
0021     threadDumpEnabled = val;
0022 }
0023 
0024 function getThreadDumpEnabled() {
0025     return threadDumpEnabled;
0026 }
0027 
0028 function formatStatus(status, type, row) {
0029     if (row.isBlacklisted) {
0030         return "Blacklisted";
0031     }
0032 
0033     if (status) {
0034         if (row.blacklistedInStages.length == 0) {
0035             return "Active"
0036         }
0037         return "Active (Blacklisted in Stages: [" + row.blacklistedInStages.join(", ") + "])";
0038     }
0039     return "Dead"
0040 }
0041 
0042 function formatResourceCells(resources) {
0043     var result = ""
0044     var count = 0
0045     $.each(resources, function (name, resInfo) {
0046         if (count > 0) {
0047             result += ", "
0048         }
0049         result += name + ': [' + resInfo.addresses.join(", ") + ']'
0050         count += 1
0051     });
0052     return result
0053 }
0054 
0055 jQuery.extend(jQuery.fn.dataTableExt.oSort, {
0056     "title-numeric-pre": function (a) {
0057         var x = a.match(/title="*(-?[0-9\.]+)/)[1];
0058         return parseFloat(x);
0059     },
0060 
0061     "title-numeric-asc": function (a, b) {
0062         return ((a < b) ? -1 : ((a > b) ? 1 : 0));
0063     },
0064 
0065     "title-numeric-desc": function (a, b) {
0066         return ((a < b) ? 1 : ((a > b) ? -1 : 0));
0067     }
0068 });
0069 
0070 $(document).ajaxStop($.unblockUI);
0071 $(document).ajaxStart(function () {
0072     $.blockUI({message: '<h3>Loading Executors Page...</h3>'});
0073 });
0074 
0075 function logsExist(execs) {
0076     return execs.some(function(exec) {
0077         return !($.isEmptyObject(exec["executorLogs"]));
0078     });
0079 }
0080 
0081 // Determine Color Opacity from 0.5-1
0082 // activeTasks range from 0 to maxTasks
0083 function activeTasksAlpha(activeTasks, maxTasks) {
0084     return maxTasks > 0 ? ((activeTasks / maxTasks) * 0.5 + 0.5) : 1;
0085 }
0086 
0087 function activeTasksStyle(activeTasks, maxTasks) {
0088     return activeTasks > 0 ? ("hsla(240, 100%, 50%, " + activeTasksAlpha(activeTasks, maxTasks) + ")") : "";
0089 }
0090 
0091 // failedTasks range max at 10% failure, alpha max = 1
0092 function failedTasksAlpha(failedTasks, totalTasks) {
0093     return totalTasks > 0 ?
0094         (Math.min(10 * failedTasks / totalTasks, 1) * 0.5 + 0.5) : 1;
0095 }
0096 
0097 function failedTasksStyle(failedTasks, totalTasks) {
0098     return failedTasks > 0 ?
0099         ("hsla(0, 100%, 50%, " + failedTasksAlpha(failedTasks, totalTasks) + ")") : "";
0100 }
0101 
0102 // totalDuration range from 0 to 50% GC time, alpha max = 1
0103 function totalDurationAlpha(totalGCTime, totalDuration) {
0104     return totalDuration > 0 ?
0105         (Math.min(totalGCTime / totalDuration + 0.5, 1)) : 1;
0106 }
0107 
0108 // When GCTimePercent is edited change ToolTips.TASK_TIME to match
0109 var GCTimePercent = 0.1;
0110 
0111 function totalDurationStyle(totalGCTime, totalDuration) {
0112     // Red if GC time over GCTimePercent of total time
0113     return (totalGCTime > GCTimePercent * totalDuration) ?
0114         ("hsla(0, 100%, 50%, " + totalDurationAlpha(totalGCTime, totalDuration) + ")") : "";
0115 }
0116 
0117 function totalDurationColor(totalGCTime, totalDuration) {
0118     return (totalGCTime > GCTimePercent * totalDuration) ? "white" : "black";
0119 }
0120 
0121 var sumOptionalColumns = [3, 4];
0122 var execOptionalColumns = [5, 6, 9];
0123 var execDataTable;
0124 var sumDataTable;
0125 
0126 function reselectCheckboxesBasedOnTaskTableState() {
0127     var allChecked = true;
0128     if (typeof execDataTable !== "undefined") {
0129         for (var k = 0; k < execOptionalColumns.length; k++) {
0130             if (execDataTable.column(execOptionalColumns[k]).visible()) {
0131                 $("[data-exec-col-idx=" + execOptionalColumns[k] + "]").prop("checked", true);
0132             } else {
0133                 allChecked = false;
0134             }
0135         }
0136     }
0137     if (allChecked) {
0138         $("#select-all-box").prop("checked", true);
0139     }
0140 }
0141 
0142 $(document).ready(function () {
0143     setDataTableDefaults();
0144 
0145     var executorsSummary = $("#active-executors");
0146 
0147     getStandAloneAppId(function (appId) {
0148 
0149         var endPoint = createRESTEndPointForExecutorsPage(appId);
0150         $.getJSON(endPoint, function (response, status, jqXHR) {
0151             var allExecCnt = 0;
0152             var allRDDBlocks = 0;
0153             var allMemoryUsed = 0;
0154             var allMaxMemory = 0;
0155             var allOnHeapMemoryUsed = 0;
0156             var allOnHeapMaxMemory = 0;
0157             var allOffHeapMemoryUsed = 0;
0158             var allOffHeapMaxMemory = 0;
0159             var allDiskUsed = 0;
0160             var allTotalCores = 0;
0161             var allMaxTasks = 0;
0162             var allActiveTasks = 0;
0163             var allFailedTasks = 0;
0164             var allCompletedTasks = 0;
0165             var allTotalTasks = 0;
0166             var allTotalDuration = 0;
0167             var allTotalGCTime = 0;
0168             var allTotalInputBytes = 0;
0169             var allTotalShuffleRead = 0;
0170             var allTotalShuffleWrite = 0;
0171             var allTotalBlacklisted = 0;
0172 
0173             var activeExecCnt = 0;
0174             var activeRDDBlocks = 0;
0175             var activeMemoryUsed = 0;
0176             var activeMaxMemory = 0;
0177             var activeOnHeapMemoryUsed = 0;
0178             var activeOnHeapMaxMemory = 0;
0179             var activeOffHeapMemoryUsed = 0;
0180             var activeOffHeapMaxMemory = 0;
0181             var activeDiskUsed = 0;
0182             var activeTotalCores = 0;
0183             var activeMaxTasks = 0;
0184             var activeActiveTasks = 0;
0185             var activeFailedTasks = 0;
0186             var activeCompletedTasks = 0;
0187             var activeTotalTasks = 0;
0188             var activeTotalDuration = 0;
0189             var activeTotalGCTime = 0;
0190             var activeTotalInputBytes = 0;
0191             var activeTotalShuffleRead = 0;
0192             var activeTotalShuffleWrite = 0;
0193             var activeTotalBlacklisted = 0;
0194 
0195             var deadExecCnt = 0;
0196             var deadRDDBlocks = 0;
0197             var deadMemoryUsed = 0;
0198             var deadMaxMemory = 0;
0199             var deadOnHeapMemoryUsed = 0;
0200             var deadOnHeapMaxMemory = 0;
0201             var deadOffHeapMemoryUsed = 0;
0202             var deadOffHeapMaxMemory = 0;
0203             var deadDiskUsed = 0;
0204             var deadTotalCores = 0;
0205             var deadMaxTasks = 0;
0206             var deadActiveTasks = 0;
0207             var deadFailedTasks = 0;
0208             var deadCompletedTasks = 0;
0209             var deadTotalTasks = 0;
0210             var deadTotalDuration = 0;
0211             var deadTotalGCTime = 0;
0212             var deadTotalInputBytes = 0;
0213             var deadTotalShuffleRead = 0;
0214             var deadTotalShuffleWrite = 0;
0215             var deadTotalBlacklisted = 0;
0216 
0217             response.forEach(function (exec) {
0218                 var memoryMetrics = {
0219                     usedOnHeapStorageMemory: 0,
0220                     usedOffHeapStorageMemory: 0,
0221                     totalOnHeapStorageMemory: 0,
0222                     totalOffHeapStorageMemory: 0
0223                 };
0224 
0225                 exec.memoryMetrics = exec.hasOwnProperty('memoryMetrics') ? exec.memoryMetrics : memoryMetrics;
0226             });
0227 
0228             response.forEach(function (exec) {
0229                 allExecCnt += 1;
0230                 allRDDBlocks += exec.rddBlocks;
0231                 allMemoryUsed += exec.memoryUsed;
0232                 allMaxMemory += exec.maxMemory;
0233                 allOnHeapMemoryUsed += exec.memoryMetrics.usedOnHeapStorageMemory;
0234                 allOnHeapMaxMemory += exec.memoryMetrics.totalOnHeapStorageMemory;
0235                 allOffHeapMemoryUsed += exec.memoryMetrics.usedOffHeapStorageMemory;
0236                 allOffHeapMaxMemory += exec.memoryMetrics.totalOffHeapStorageMemory;
0237                 allDiskUsed += exec.diskUsed;
0238                 allTotalCores += exec.totalCores;
0239                 allMaxTasks += exec.maxTasks;
0240                 allActiveTasks += exec.activeTasks;
0241                 allFailedTasks += exec.failedTasks;
0242                 allCompletedTasks += exec.completedTasks;
0243                 allTotalTasks += exec.totalTasks;
0244                 allTotalDuration += exec.totalDuration;
0245                 allTotalGCTime += exec.totalGCTime;
0246                 allTotalInputBytes += exec.totalInputBytes;
0247                 allTotalShuffleRead += exec.totalShuffleRead;
0248                 allTotalShuffleWrite += exec.totalShuffleWrite;
0249                 allTotalBlacklisted += exec.isBlacklisted ? 1 : 0;
0250                 if (exec.isActive) {
0251                     activeExecCnt += 1;
0252                     activeRDDBlocks += exec.rddBlocks;
0253                     activeMemoryUsed += exec.memoryUsed;
0254                     activeMaxMemory += exec.maxMemory;
0255                     activeOnHeapMemoryUsed += exec.memoryMetrics.usedOnHeapStorageMemory;
0256                     activeOnHeapMaxMemory += exec.memoryMetrics.totalOnHeapStorageMemory;
0257                     activeOffHeapMemoryUsed += exec.memoryMetrics.usedOffHeapStorageMemory;
0258                     activeOffHeapMaxMemory += exec.memoryMetrics.totalOffHeapStorageMemory;
0259                     activeDiskUsed += exec.diskUsed;
0260                     activeTotalCores += exec.totalCores;
0261                     activeMaxTasks += exec.maxTasks;
0262                     activeActiveTasks += exec.activeTasks;
0263                     activeFailedTasks += exec.failedTasks;
0264                     activeCompletedTasks += exec.completedTasks;
0265                     activeTotalTasks += exec.totalTasks;
0266                     activeTotalDuration += exec.totalDuration;
0267                     activeTotalGCTime += exec.totalGCTime;
0268                     activeTotalInputBytes += exec.totalInputBytes;
0269                     activeTotalShuffleRead += exec.totalShuffleRead;
0270                     activeTotalShuffleWrite += exec.totalShuffleWrite;
0271                     activeTotalBlacklisted += exec.isBlacklisted ? 1 : 0;
0272                 } else {
0273                     deadExecCnt += 1;
0274                     deadRDDBlocks += exec.rddBlocks;
0275                     deadMemoryUsed += exec.memoryUsed;
0276                     deadMaxMemory += exec.maxMemory;
0277                     deadOnHeapMemoryUsed += exec.memoryMetrics.usedOnHeapStorageMemory;
0278                     deadOnHeapMaxMemory += exec.memoryMetrics.totalOnHeapStorageMemory;
0279                     deadOffHeapMemoryUsed += exec.memoryMetrics.usedOffHeapStorageMemory;
0280                     deadOffHeapMaxMemory += exec.memoryMetrics.totalOffHeapStorageMemory;
0281                     deadDiskUsed += exec.diskUsed;
0282                     deadTotalCores += exec.totalCores;
0283                     deadMaxTasks += exec.maxTasks;
0284                     deadActiveTasks += exec.activeTasks;
0285                     deadFailedTasks += exec.failedTasks;
0286                     deadCompletedTasks += exec.completedTasks;
0287                     deadTotalTasks += exec.totalTasks;
0288                     deadTotalDuration += exec.totalDuration;
0289                     deadTotalGCTime += exec.totalGCTime;
0290                     deadTotalInputBytes += exec.totalInputBytes;
0291                     deadTotalShuffleRead += exec.totalShuffleRead;
0292                     deadTotalShuffleWrite += exec.totalShuffleWrite;
0293                     deadTotalBlacklisted += exec.isBlacklisted ? 1 : 0;
0294                 }
0295             });
0296 
0297             var totalSummary = {
0298                 "execCnt": ( "Total(" + allExecCnt + ")"),
0299                 "allRDDBlocks": allRDDBlocks,
0300                 "allMemoryUsed": allMemoryUsed,
0301                 "allMaxMemory": allMaxMemory,
0302                 "allOnHeapMemoryUsed": allOnHeapMemoryUsed,
0303                 "allOnHeapMaxMemory": allOnHeapMaxMemory,
0304                 "allOffHeapMemoryUsed": allOffHeapMemoryUsed,
0305                 "allOffHeapMaxMemory": allOffHeapMaxMemory,
0306                 "allDiskUsed": allDiskUsed,
0307                 "allTotalCores": allTotalCores,
0308                 "allMaxTasks": allMaxTasks,
0309                 "allActiveTasks": allActiveTasks,
0310                 "allFailedTasks": allFailedTasks,
0311                 "allCompletedTasks": allCompletedTasks,
0312                 "allTotalTasks": allTotalTasks,
0313                 "allTotalDuration": allTotalDuration,
0314                 "allTotalGCTime": allTotalGCTime,
0315                 "allTotalInputBytes": allTotalInputBytes,
0316                 "allTotalShuffleRead": allTotalShuffleRead,
0317                 "allTotalShuffleWrite": allTotalShuffleWrite,
0318                 "allTotalBlacklisted": allTotalBlacklisted
0319             };
0320             var activeSummary = {
0321                 "execCnt": ( "Active(" + activeExecCnt + ")"),
0322                 "allRDDBlocks": activeRDDBlocks,
0323                 "allMemoryUsed": activeMemoryUsed,
0324                 "allMaxMemory": activeMaxMemory,
0325                 "allOnHeapMemoryUsed": activeOnHeapMemoryUsed,
0326                 "allOnHeapMaxMemory": activeOnHeapMaxMemory,
0327                 "allOffHeapMemoryUsed": activeOffHeapMemoryUsed,
0328                 "allOffHeapMaxMemory": activeOffHeapMaxMemory,
0329                 "allDiskUsed": activeDiskUsed,
0330                 "allTotalCores": activeTotalCores,
0331                 "allMaxTasks": activeMaxTasks,
0332                 "allActiveTasks": activeActiveTasks,
0333                 "allFailedTasks": activeFailedTasks,
0334                 "allCompletedTasks": activeCompletedTasks,
0335                 "allTotalTasks": activeTotalTasks,
0336                 "allTotalDuration": activeTotalDuration,
0337                 "allTotalGCTime": activeTotalGCTime,
0338                 "allTotalInputBytes": activeTotalInputBytes,
0339                 "allTotalShuffleRead": activeTotalShuffleRead,
0340                 "allTotalShuffleWrite": activeTotalShuffleWrite,
0341                 "allTotalBlacklisted": activeTotalBlacklisted
0342             };
0343             var deadSummary = {
0344                 "execCnt": ( "Dead(" + deadExecCnt + ")" ),
0345                 "allRDDBlocks": deadRDDBlocks,
0346                 "allMemoryUsed": deadMemoryUsed,
0347                 "allMaxMemory": deadMaxMemory,
0348                 "allOnHeapMemoryUsed": deadOnHeapMemoryUsed,
0349                 "allOnHeapMaxMemory": deadOnHeapMaxMemory,
0350                 "allOffHeapMemoryUsed": deadOffHeapMemoryUsed,
0351                 "allOffHeapMaxMemory": deadOffHeapMaxMemory,
0352                 "allDiskUsed": deadDiskUsed,
0353                 "allTotalCores": deadTotalCores,
0354                 "allMaxTasks": deadMaxTasks,
0355                 "allActiveTasks": deadActiveTasks,
0356                 "allFailedTasks": deadFailedTasks,
0357                 "allCompletedTasks": deadCompletedTasks,
0358                 "allTotalTasks": deadTotalTasks,
0359                 "allTotalDuration": deadTotalDuration,
0360                 "allTotalGCTime": deadTotalGCTime,
0361                 "allTotalInputBytes": deadTotalInputBytes,
0362                 "allTotalShuffleRead": deadTotalShuffleRead,
0363                 "allTotalShuffleWrite": deadTotalShuffleWrite,
0364                 "allTotalBlacklisted": deadTotalBlacklisted
0365             };
0366 
0367             var data = {executors: response, "execSummary": [activeSummary, deadSummary, totalSummary]};
0368             $.get(createTemplateURI(appId, "executorspage"), function (template) {
0369 
0370                 executorsSummary.append(Mustache.render($(template).filter("#executors-summary-template").html(), data));
0371                 var selector = "#active-executors-table";
0372                 var conf = {
0373                     "data": response,
0374                     "columns": [
0375                         {
0376                             data: function (row, type) {
0377                                 return type !== 'display' ? (isNaN(row.id) ? 0 : row.id ) : row.id;
0378                             }
0379                         },
0380                         {data: 'hostPort'},
0381                         {
0382                             data: 'isActive',
0383                             render: function (data, type, row) {
0384                                 return formatStatus (data, type, row);
0385                             }
0386                         },
0387                         {data: 'rddBlocks'},
0388                         {
0389                             data: function (row, type) {
0390                                 if (type !== 'display')
0391                                     return row.memoryUsed;
0392                                 else
0393                                     return (formatBytes(row.memoryUsed, type) + ' / ' +
0394                                         formatBytes(row.maxMemory, type));
0395                             }
0396                         },
0397                         {
0398                             data: function (row, type) {
0399                                 if (type !== 'display')
0400                                     return row.memoryMetrics.usedOnHeapStorageMemory;
0401                                 else
0402                                     return (formatBytes(row.memoryMetrics.usedOnHeapStorageMemory, type) + ' / ' +
0403                                         formatBytes(row.memoryMetrics.totalOnHeapStorageMemory, type));
0404                             }
0405                         },
0406                         {
0407                             data: function (row, type) {
0408                                 if (type !== 'display')
0409                                     return row.memoryMetrics.usedOffHeapStorageMemory;
0410                                 else
0411                                     return (formatBytes(row.memoryMetrics.usedOffHeapStorageMemory, type) + ' / ' +
0412                                         formatBytes(row.memoryMetrics.totalOffHeapStorageMemory, type));
0413                             }
0414                         },
0415                         {data: 'diskUsed', render: formatBytes},
0416                         {data: 'totalCores'},
0417                         {name: 'resourcesCol', data: 'resources', render: formatResourceCells, orderable: false},
0418                         {
0419                             data: 'activeTasks',
0420                             "fnCreatedCell": function (nTd, sData, oData, iRow, iCol) {
0421                                 if (sData > 0) {
0422                                     $(nTd).css('color', 'white');
0423                                     $(nTd).css('background', activeTasksStyle(oData.activeTasks, oData.maxTasks));
0424                                 }
0425                             }
0426                         },
0427                         {
0428                             data: 'failedTasks',
0429                             "fnCreatedCell": function (nTd, sData, oData, iRow, iCol) {
0430                                 if (sData > 0) {
0431                                     $(nTd).css('color', 'white');
0432                                     $(nTd).css('background', failedTasksStyle(oData.failedTasks, oData.totalTasks));
0433                                 }
0434                             }
0435                         },
0436                         {data: 'completedTasks'},
0437                         {data: 'totalTasks'},
0438                         {
0439                             data: function (row, type) {
0440                                 return type === 'display' ? (formatDuration(row.totalDuration) + ' (' + formatDuration(row.totalGCTime) + ')') : row.totalDuration
0441                             },
0442                             "fnCreatedCell": function (nTd, sData, oData, iRow, iCol) {
0443                                 if (oData.totalDuration > 0) {
0444                                     $(nTd).css('color', totalDurationColor(oData.totalGCTime, oData.totalDuration));
0445                                     $(nTd).css('background', totalDurationStyle(oData.totalGCTime, oData.totalDuration));
0446                                 }
0447                             }
0448                         },
0449                         {data: 'totalInputBytes', render: formatBytes},
0450                         {data: 'totalShuffleRead', render: formatBytes},
0451                         {data: 'totalShuffleWrite', render: formatBytes},
0452                         {name: 'executorLogsCol', data: 'executorLogs', render: formatLogsCells},
0453                         {
0454                             name: 'threadDumpCol',
0455                             data: 'id', render: function (data, type) {
0456                                 return type === 'display' ? ("<a href='threadDump/?executorId=" + data + "'>Thread Dump</a>" ) : data;
0457                             }
0458                         }
0459                     ],
0460                     "order": [[0, "asc"]],
0461                     "columnDefs": [
0462                         {"visible": false, "targets": 5},
0463                         {"visible": false, "targets": 6},
0464                         {"visible": false, "targets": 9}
0465                     ],
0466                     "deferRender": true
0467                 };
0468 
0469                 execDataTable = $(selector).DataTable(conf);
0470                 execDataTable.column('executorLogsCol:name').visible(logsExist(response));
0471                 execDataTable.column('threadDumpCol:name').visible(getThreadDumpEnabled());
0472                 $('#active-executors [data-toggle="tooltip"]').tooltip();
0473     
0474                 var sumSelector = "#summary-execs-table";
0475                 var sumConf = {
0476                     "data": [activeSummary, deadSummary, totalSummary],
0477                     "columns": [
0478                         {
0479                             data: 'execCnt',
0480                             "fnCreatedCell": function (nTd, sData, oData, iRow, iCol) {
0481                                 $(nTd).css('font-weight', 'bold');
0482                             }
0483                         },
0484                         {data: 'allRDDBlocks'},
0485                         {
0486                             data: function (row, type) {
0487                                 if (type !== 'display')
0488                                     return row.allMemoryUsed
0489                                 else
0490                                     return (formatBytes(row.allMemoryUsed, type) + ' / ' +
0491                                         formatBytes(row.allMaxMemory, type));
0492                             }
0493                         },
0494                         {
0495                             data: function (row, type) {
0496                                 if (type !== 'display')
0497                                     return row.allOnHeapMemoryUsed;
0498                                 else
0499                                     return (formatBytes(row.allOnHeapMemoryUsed, type) + ' / ' +
0500                                         formatBytes(row.allOnHeapMaxMemory, type));
0501                             }
0502                         },
0503                         {
0504                             data: function (row, type) {
0505                                 if (type !== 'display')
0506                                     return row.allOffHeapMemoryUsed;
0507                                 else
0508                                     return (formatBytes(row.allOffHeapMemoryUsed, type) + ' / ' +
0509                                         formatBytes(row.allOffHeapMaxMemory, type));
0510                             }
0511                         },
0512                         {data: 'allDiskUsed', render: formatBytes},
0513                         {data: 'allTotalCores'},
0514                         {
0515                             data: 'allActiveTasks',
0516                             "fnCreatedCell": function (nTd, sData, oData, iRow, iCol) {
0517                                 if (sData > 0) {
0518                                     $(nTd).css('color', 'white');
0519                                     $(nTd).css('background', activeTasksStyle(oData.allActiveTasks, oData.allMaxTasks));
0520                                 }
0521                             }
0522                         },
0523                         {
0524                             data: 'allFailedTasks',
0525                             "fnCreatedCell": function (nTd, sData, oData, iRow, iCol) {
0526                                 if (sData > 0) {
0527                                     $(nTd).css('color', 'white');
0528                                     $(nTd).css('background', failedTasksStyle(oData.allFailedTasks, oData.allTotalTasks));
0529                                 }
0530                             }
0531                         },
0532                         {data: 'allCompletedTasks'},
0533                         {data: 'allTotalTasks'},
0534                         {
0535                             data: function (row, type) {
0536                                 return type === 'display' ? (formatDuration(row.allTotalDuration) + ' (' + formatDuration(row.allTotalGCTime) + ')') : row.allTotalDuration
0537                             },
0538                             "fnCreatedCell": function (nTd, sData, oData, iRow, iCol) {
0539                                 if (oData.allTotalDuration > 0) {
0540                                     $(nTd).css('color', totalDurationColor(oData.allTotalGCTime, oData.allTotalDuration));
0541                                     $(nTd).css('background', totalDurationStyle(oData.allTotalGCTime, oData.allTotalDuration));
0542                                 }
0543                             }
0544                         },
0545                         {data: 'allTotalInputBytes', render: formatBytes},
0546                         {data: 'allTotalShuffleRead', render: formatBytes},
0547                         {data: 'allTotalShuffleWrite', render: formatBytes},
0548                         {data: 'allTotalBlacklisted'}
0549                     ],
0550                     "paging": false,
0551                     "searching": false,
0552                     "info": false,
0553                     "columnDefs": [
0554                         {"visible": false, "targets": 3},
0555                         {"visible": false, "targets": 4}
0556                     ]
0557 
0558                 };
0559     
0560                 sumDataTable = $(sumSelector).DataTable(sumConf);
0561                 $('#execSummary [data-toggle="tooltip"]').tooltip();
0562 
0563                 $("#showAdditionalMetrics").append(
0564                     "<div><a id='additionalMetrics'>" +
0565                     "<span class='expand-input-rate-arrow arrow-closed' id='arrowtoggle-optional-metrics'></span>" +
0566                     "Show Additional Metrics" +
0567                     "</a></div>" +
0568                     "<div class='container-fluid container-fluid-div' id='toggle-metrics' hidden>" +
0569                     "<div><input type='checkbox' class='toggle-vis' id='select-all-box'>Select All</div>" +
0570                     "<div id='on_heap_memory' class='on-heap-memory-checkbox-div'><input type='checkbox' class='toggle-vis' data-sum-col-idx='3' data-exec-col-idx='5'>On Heap Memory</div>" +
0571                     "<div id='off_heap_memory' class='off-heap-memory-checkbox-div'><input type='checkbox' class='toggle-vis' data-sum-col-idx='4' data-exec-col-idx='6'>Off Heap Memory</div>" +
0572                     "<div id='extra_resources' class='resources-checkbox-div'><input type='checkbox' class='toggle-vis' data-sum-col-idx='' data-exec-col-idx='9'>Resources</div>" +
0573                     "</div>");
0574 
0575                 reselectCheckboxesBasedOnTaskTableState();
0576 
0577                 $("#additionalMetrics").click(function() {
0578                     $("#arrowtoggle-optional-metrics").toggleClass("arrow-open arrow-closed");
0579                     $("#toggle-metrics").toggle();
0580                     if (window.localStorage) {
0581                         window.localStorage.setItem("arrowtoggle-optional-metrics-class", $("#arrowtoggle-optional-metrics").attr('class'));
0582                     }
0583                 });
0584 
0585                 $(".toggle-vis").on("click", function() {
0586                     var thisBox = $(this);
0587                     if (thisBox.is("#select-all-box")) {
0588                         var sumColumn = sumDataTable.columns(sumOptionalColumns);
0589                         var execColumn = execDataTable.columns(execOptionalColumns);
0590                         if (thisBox.is(":checked")) {
0591                             $(".toggle-vis").prop("checked", true);
0592                             sumColumn.visible(true);
0593                             execColumn.visible(true);
0594                         } else {
0595                             $(".toggle-vis").prop("checked", false);
0596                             sumColumn.visible(false);
0597                             execColumn.visible(false);
0598                         }
0599                     } else {
0600                         var execColIdx = thisBox.attr("data-exec-col-idx");
0601                         var execCol = execDataTable.column(execColIdx);
0602                         execCol.visible(!execCol.visible());
0603                         var sumColIdx = thisBox.attr("data-sum-col-idx");
0604                         if (sumColIdx) {
0605                             var sumCol = sumDataTable.column(sumColIdx);
0606                             sumCol.visible(!sumCol.visible());
0607                         }
0608                     }
0609                 });
0610 
0611                 if (window.localStorage) {
0612                     if (window.localStorage.getItem("arrowtoggle-optional-metrics-class") != null &&
0613                         window.localStorage.getItem("arrowtoggle-optional-metrics-class").includes("arrow-open")) {
0614                         $("#arrowtoggle-optional-metrics").toggleClass("arrow-open arrow-closed");
0615                         $("#toggle-metrics").toggle();
0616                     }
0617                 }
0618             });
0619         });
0620     });
0621 });
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!