| /** |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| var App = require('app'); |
| |
| /** |
| * App.HostPopup is for the popup that shows up upon clicking already-performed or currently-in-progress operations |
| */ |
| App.HostPopup = Em.Object.create({ |
| |
| servicesInfo: null, |
| hosts: null, |
| inputData: null, |
| serviceName: "", |
| currentServiceId: null, |
| previousServiceId: null, |
| popupHeaderName: "", |
| dataSourceController: null, |
| isBackgroundOperations: false, |
| currentHostName: null, |
| isPopup: null, |
| |
| /** |
| * Sort object array |
| * @param array |
| * @param p |
| * @return {*} |
| */ |
| sortArray: function (array, p) { |
| return array.sort(function (a, b) { |
| return (a[p] > b[p]) ? 1 : (a[p] < b[p]) ? -1 : 0; |
| }); |
| }, |
| |
| /** |
| * Entering point of this component |
| * @param serviceName |
| * @param controller |
| * @param isBackgroundOperations |
| */ |
| initPopup: function (serviceName, controller, isBackgroundOperations) { |
| if (!isBackgroundOperations) { |
| this.clearHostPopup(); |
| this.set("popupHeaderName", serviceName); |
| } |
| this.set("serviceName", serviceName); |
| this.set("dataSourceController", controller); |
| this.set("isBackgroundOperations", isBackgroundOperations); |
| this.set("inputData", this.get("dataSourceController.services")); |
| if(isBackgroundOperations){ |
| this.onServiceUpdate(); |
| } else { |
| this.onHostUpdate(); |
| } |
| return this.createPopup(); |
| }, |
| |
| clearHostPopup: function () { |
| this.set('servicesInfo', null); |
| this.set('hosts', null); |
| this.set('inputData', null); |
| this.set('serviceName', ""); |
| this.set('currentServiceId', null); |
| this.set('previousServiceId', null); |
| this.set('popupHeaderName', ""); |
| this.set('dataSourceController', null); |
| this.set('currentHostName', null); |
| this.get('isPopup') ? this.get('isPopup').remove() : null; |
| }, |
| |
| /** |
| * Depending on tasks status |
| * @param tasks |
| * @return {Array} [Status, Icon type, Progressbar color, is IN_PROGRESS] |
| */ |
| getStatus: function(tasks){ |
| var isCompleted = true; |
| var status; |
| var tasksLength = tasks.length; |
| var isFailed = false; |
| var isAborted = false; |
| var isTimedout = false; |
| var isInProgress = false; |
| for (var i = 0; i < tasksLength; i++) { |
| if (tasks[i].Tasks.status !== 'COMPLETED') { |
| isCompleted = false; |
| } |
| if(tasks[i].Tasks.status === 'FAILED'){ |
| isFailed = true; |
| } |
| if (tasks[i].Tasks.status === 'ABORTED') { |
| isAborted = true; |
| } |
| if (tasks[i].Tasks.status === 'TIMEDOUT') { |
| isTimedout = true; |
| } |
| if (tasks[i].Tasks.status === 'IN_PROGRESS') { |
| isInProgress = true; |
| } |
| } |
| if (isFailed) { |
| status = ['FAILED', 'icon-exclamation-sign', 'progress-danger', false]; |
| } else if (isAborted) { |
| status = ['CANCELLED', 'icon-minus', 'progress-warning', false]; |
| } else if (isTimedout) { |
| status = ['TIMEDOUT', 'icon-time', 'progress-warning', false]; |
| } else if (isInProgress) { |
| status = ['IN_PROGRESS', 'icon-cogs', 'progress-info', true]; |
| } |
| if(status){ |
| return status; |
| } else if(isCompleted){ |
| return ['SUCCESS', 'icon-ok', 'progress-success', false]; |
| } else { |
| return ['PENDING', 'icon-cog', 'progress-info', true]; |
| } |
| }, |
| |
| /** |
| * Progress of host or service depending on tasks status |
| * @param tasks |
| * @return {Number} percent of completion |
| */ |
| getProgress: function (tasks) { |
| var completedActions = 0; |
| var queuedActions = 0; |
| var inProgressActions = 0; |
| tasks.forEach(function(task){ |
| if(['COMPLETED', 'FAILED', 'ABORTED', 'TIMEDOUT'].contains(task.Tasks.status)){ |
| completedActions++; |
| } else if(task.Tasks.status === 'QUEUED'){ |
| queuedActions++; |
| } else if(task.Tasks.status === 'IN_PROGRESS'){ |
| inProgressActions++; |
| } |
| }); |
| return Math.ceil(((queuedActions * 0.09) + (inProgressActions * 0.35) + completedActions ) / tasks.length * 100); |
| }, |
| /** |
| * Count number of operations for select box options |
| * @param obj |
| * @param categories |
| */ |
| setSelectCount: function (obj, categories) { |
| if (!obj) return; |
| var countAll = obj.length; |
| var countPending = 0; |
| var countInProgress = 0; |
| var countFailed = 0; |
| var countCompleted = 0; |
| var countAborted = 0; |
| var countTimedout = 0; |
| obj.forEach(function(item){ |
| switch (item.status){ |
| case 'pending': |
| countPending++; |
| break; |
| case 'queued': |
| countPending++; |
| break; |
| case 'in_progress': |
| countInProgress++; |
| break; |
| case 'failed': |
| countFailed++; |
| break; |
| case 'success': |
| countCompleted++; |
| break; |
| case 'completed': |
| countCompleted++; |
| break; |
| case 'aborted': |
| countAborted++; |
| break; |
| case 'timedout': |
| countTimedout++; |
| break; |
| } |
| }, this); |
| |
| categories.findProperty("value", 'all').set("count", countAll); |
| categories.findProperty("value", 'pending').set("count", countPending); |
| categories.findProperty("value", 'in_progress').set("count", countInProgress); |
| categories.findProperty("value", 'failed').set("count", countFailed); |
| categories.findProperty("value", 'completed').set("count", countCompleted); |
| categories.findProperty("value", 'aborted').set("count", countAborted); |
| categories.findProperty("value", 'timedout').set("count", countTimedout); |
| }, |
| |
| /** |
| * For Background operation popup calculate number of running Operations, and set popup header |
| * @param isServiceListHidden |
| */ |
| setBackgroundOperationHeader: function (isServiceListHidden) { |
| if (this.get('isBackgroundOperations') && !isServiceListHidden) { |
| var numRunning = App.router.get('backgroundOperationsController.allOperationsCount'); |
| this.set("popupHeaderName", numRunning + Em.I18n.t('hostPopup.header.postFix')); |
| } |
| }, |
| |
| /** |
| * Create services obj data structure for popup |
| * Set data for services |
| */ |
| onServiceUpdate: function (isServiceListHidden) { |
| if (this.get('isBackgroundOperations') && this.get("inputData")) { |
| var self = this; |
| var allNewServices = []; |
| var statuses = { |
| 'FAILED': ['FAILED', 'icon-exclamation-sign', 'progress-danger', false], |
| 'ABORTED': ['CANCELLED', 'icon-minus', 'progress-warning', false], |
| 'TIMEDOUT': ['TIMEDOUT', 'icon-time', 'progress-warning', false], |
| 'IN_PROGRESS': ['IN_PROGRESS', 'icon-cogs', 'progress-info', true], |
| 'COMPLETED': ['SUCCESS', 'icon-ok', 'progress-success', false] |
| }; |
| var pendingStatus = ['PENDING', 'icon-cog', 'progress-info', true]; |
| this.set("servicesInfo", null); |
| this.get("inputData").forEach(function (service) { |
| var status = statuses[service.status] || pendingStatus; |
| var newService = Ember.Object.create({ |
| id: service.id, |
| displayName: service.displayName, |
| progress: service.progress, |
| status: App.format.taskStatus(status[0]), |
| isRunning: service.isRunning, |
| name: service.name, |
| isVisible: true, |
| icon: status[1], |
| barColor: status[2], |
| isInProgress: status[3], |
| barWidth: "width:" + service.progress + "%;" |
| }); |
| allNewServices.push(newService); |
| }); |
| self.set('servicesInfo', allNewServices); |
| this.setBackgroundOperationHeader(isServiceListHidden); |
| } |
| }, |
| |
| /** |
| * update icon of task depending on its status |
| * @param taskInfo |
| */ |
| updateTaskIcon: function(taskInfo){ |
| if (taskInfo.get('status') == 'pending' || taskInfo.get('status') == 'queued') { |
| taskInfo.set('icon', 'icon-cog'); |
| } else if (taskInfo.get('status') == 'in_progress') { |
| taskInfo.set('icon', 'icon-cogs'); |
| } else if (taskInfo.get('status') == 'completed') { |
| taskInfo.set('icon', ' icon-ok'); |
| } else if (taskInfo.get('status') == 'failed') { |
| taskInfo.set('icon', 'icon-exclamation-sign'); |
| } else if (taskInfo.get('status') == 'aborted') { |
| taskInfo.set('icon', 'icon-minus'); |
| } else if (taskInfo.get('status') == 'timedout') { |
| taskInfo.set('icon', 'icon-time'); |
| } |
| }, |
| /** |
| * Create hosts and tasks data structure for popup |
| * Set data for hosts and tasks |
| */ |
| onHostUpdate: function () { |
| var self = this; |
| var inputData = this.get("inputData"); |
| if (inputData) { |
| var hostsArr = []; |
| var hostsData; |
| var hostsMap = {}; |
| |
| if(this.get('isBackgroundOperations') && this.get("currentServiceId")){ |
| //hosts popup for Background Operations |
| hostsData = inputData.findProperty("id", this.get("currentServiceId")); |
| } else if (this.get("serviceName")) { |
| //hosts popup for Wizards |
| hostsData = inputData.findProperty("name", this.get("serviceName")); |
| } |
| if (hostsData) { |
| if (hostsData.hostsMap) { |
| //hosts data come from Background Operations as object map |
| hostsMap = hostsData.hostsMap; |
| } else if (hostsData.hosts) { |
| //hosts data come from Wizard as array |
| hostsData.hosts.forEach(function (_host) { |
| hostsMap[_host.name] = _host; |
| }); |
| } |
| } |
| var existedHosts = self.get('hosts'); |
| |
| if (existedHosts && (existedHosts.length > 0) && this.get('currentServiceId') === this.get('previousServiceId')) { |
| existedHosts.forEach(function (host) { |
| var newHostInfo = hostsMap[host.get('name')]; |
| if (newHostInfo) { |
| var hostStatus = self.getStatus(newHostInfo.logTasks); |
| var hostProgress = self.getProgress(newHostInfo.logTasks); |
| host.set('status', App.format.taskStatus(hostStatus[0])); |
| host.set('icon', hostStatus[1]); |
| host.set('barColor', hostStatus[2]); |
| host.set('isInProgress', hostStatus[3]); |
| host.set('progress', hostProgress); |
| host.set('barWidth', "width:" + hostProgress + "%;"); |
| var existTasks = host.get('tasks'); |
| var newTasks = newHostInfo.logTasks; |
| if (existTasks && newTasks && existTasks.length == newTasks.length) { |
| // Same number of source and destinations |
| var existTaskMap = {}; |
| var newTaskMap = {}; |
| host.get('tasks').forEach(function (taskInfo) { |
| var id = taskInfo.get('id'); |
| existTaskMap[id] = taskInfo; |
| }); |
| var newTasksArray = []; |
| newTasks.forEach(function (newTask) { |
| var existTask = existTaskMap[newTask.Tasks.id]; |
| if (existTask) { |
| // reuse |
| existTask.set('status', App.format.taskStatus(newTask.Tasks.status)); |
| existTask.set('stderr', newTask.Tasks.stderr); |
| existTask.set('stdout', newTask.Tasks.stdout); |
| self.updateTaskIcon(existTask); |
| delete existTaskMap[newTask.Tasks.id]; |
| } else { |
| // create new |
| var taskInfo = Ember.Object.create({ |
| id: newTask.Tasks.id, |
| hostName: newHostInfo.publicName, |
| command: newTask.Tasks.command.toLowerCase(), |
| status: App.format.taskStatus(newTask.Tasks.status), |
| role: App.format.role(newTask.Tasks.role), |
| stderr: newTask.Tasks.stderr, |
| stdout: newTask.Tasks.stdout, |
| isVisible: true, |
| icon: 'icon-cogs' |
| }); |
| self.updateTaskIcon(taskInfo); |
| newTasksArray.push(taskInfo); |
| } |
| }); |
| for (var id in existTaskMap) { |
| host.get('tasks').removeObject(existTaskMap[id]); |
| } |
| if (newTasksArray.length) { |
| host.get('tasks').pushObjects(newTasksArray); |
| } |
| } else { |
| // Tasks have changed |
| var tasksArr = []; |
| newTasks.forEach(function (newTask) { |
| var taskInfo = Ember.Object.create({ |
| id: newTask.Tasks.id, |
| hostName: newHostInfo.publicName, |
| command: newTask.Tasks.command.toLowerCase(), |
| status: App.format.taskStatus(newTask.Tasks.status), |
| role: App.format.role(newTask.Tasks.role), |
| stderr: newTask.Tasks.stderr, |
| stdout: newTask.Tasks.stdout, |
| isVisible: true, |
| icon: 'icon-cogs' |
| }); |
| self.updateTaskIcon(taskInfo); |
| tasksArr.push(taskInfo); |
| }); |
| host.set('tasks', tasksArr); |
| } |
| } |
| }, this); |
| } else { |
| for (var hostName in hostsMap) { |
| var _host = hostsMap[hostName]; |
| var tasks = _host.logTasks; |
| var hostInfo = Ember.Object.create({ |
| name: hostName, |
| publicName: _host.publicName, |
| progress: 0, |
| status: App.format.taskStatus("PENDING"), |
| serviceName: _host.serviceName, |
| isVisible: true, |
| icon: "icon-cog", |
| barColor: "progress-info", |
| barWidth: "width:0%;" |
| }); |
| |
| var tasksArr = []; |
| |
| if (tasks.length) { |
| tasks = self.sortTasksById(tasks); |
| var hostStatus = self.getStatus(tasks); |
| var hostProgress = self.getProgress(tasks); |
| hostInfo.set('status', App.format.taskStatus(hostStatus[0])); |
| hostInfo.set('icon', hostStatus[1]); |
| hostInfo.set('barColor', hostStatus[2]); |
| hostInfo.set('isInProgress', hostStatus[3]); |
| hostInfo.set('progress', hostProgress); |
| hostInfo.set('barWidth', "width:" + hostProgress + "%;"); |
| |
| tasks.forEach(function (_task) { |
| var taskInfo = Ember.Object.create({ |
| id: _task.Tasks.id, |
| hostName: _host.publicName, |
| command: _task.Tasks.command.toLowerCase(), |
| status: App.format.taskStatus(_task.Tasks.status), |
| role: App.format.role(_task.Tasks.role), |
| stderr: _task.Tasks.stderr, |
| stdout: _task.Tasks.stdout, |
| isVisible: true, |
| icon: 'icon-cogs' |
| }); |
| this.updateTaskIcon(taskInfo); |
| tasksArr.push(taskInfo); |
| }, this); |
| } |
| |
| hostInfo.set('tasks', tasksArr); |
| hostsArr.push(hostInfo); |
| } |
| //sort hosts by name |
| this.sortArray(hostsArr, "name"); |
| hostsArr.setEach("serviceName", this.get("serviceName")); |
| self.set("hosts", hostsArr); |
| self.set('previousServiceId', this.get('currentServiceId')); |
| } |
| } |
| }, |
| |
| /** |
| * Sort tasks by it`s id |
| * @param tasks |
| * @return {Array} |
| */ |
| sortTasksById: function (tasks) { |
| return tasks.sort(function (a, b) { |
| return (a.Tasks.id > b.Tasks.id) ? 1 : (a.Tasks.id < b.Tasks.id) ? -1 : 0; |
| }); |
| }, |
| |
| /** |
| * Show popup |
| * @return PopupObject For testing purposes |
| */ |
| createPopup: function () { |
| var self = this; |
| var hostsInfo = this.get("hosts"); |
| var servicesInfo = this.get("servicesInfo"); |
| var isBackgroundOperations = this.get('isBackgroundOperations'); |
| var categoryObject = Em.Object.extend({ |
| value: '', |
| count: 0, |
| labelPath: '', |
| label: function(){ |
| return Em.I18n.t(this.get('labelPath')).format(this.get('count')); |
| }.property('count') |
| }); |
| self.set('isPopup', App.ModalPopup.show({ |
| //no need to track is it loaded when popup contain only list of hosts |
| isLoaded: !isBackgroundOperations, |
| isOpen: false, |
| didInsertElement: function(){ |
| this.set('isOpen', true); |
| }, |
| headerClass: Ember.View.extend({ |
| controller: this, |
| template: Ember.Handlebars.compile('{{popupHeaderName}}') |
| }), |
| classNames: ['sixty-percent-width-modal'], |
| // for the checkbox: do not show this dialog again |
| hasFooterCheckbox: true, |
| isNotShowBgChecked : null, |
| updateNotShowBgChecked: function () { |
| var curVal = !this.get('isNotShowBgChecked'); |
| var key = App.router.get('applicationController').persistKey(); |
| if (!App.testMode) { |
| App.router.get('applicationController').postUserPref(key, curVal); |
| } |
| }.observes('isNotShowBgChecked'), |
| |
| autoHeight: false, |
| closeModelPopup: function () { |
| this.set('isOpen', false); |
| if(isBackgroundOperations){ |
| $(this.get('element')).detach(); |
| App.router.get('backgroundOperationsController').set('levelInfo.name', 'REQUESTS_LIST'); |
| } else { |
| this.hide(); |
| self.set('isPopup', null); |
| } |
| }, |
| onPrimary: function () { |
| this.closeModelPopup(); |
| }, |
| onClose: function () { |
| this.closeModelPopup(); |
| }, |
| secondary: null, |
| |
| bodyClass: Ember.View.extend({ |
| templateName: require('templates/common/host_progress_popup'), |
| isLogWrapHidden: true, |
| isTaskListHidden: true, |
| isHostListHidden: true, |
| isServiceListHidden: false, |
| showTextArea: false, |
| isServiceEmptyList: true, |
| isHostEmptyList: true, |
| isTasksEmptyList: true, |
| controller: this, |
| hosts: self.get("hosts"), |
| services: self.get('servicesInfo'), |
| |
| tasks: function () { |
| if (this.get('hosts') && this.get('hosts').length && this.get('controller.currentHostName')) { |
| var currentHost = this.get('hosts').findProperty('name', this.get('controller.currentHostName')); |
| if (currentHost) { |
| return currentHost.get('tasks'); |
| } |
| } |
| return []; |
| }.property('hosts.@each.tasks', 'hosts.@each.tasks.@each.status'), |
| |
| /** |
| * Preset values on init |
| */ |
| setOnStart: function () { |
| if (this.get("controller.isBackgroundOperations")) { |
| this.get('controller').setSelectCount(this.get("services"), this.get('categories')); |
| this.updateHostInfo(); |
| } else { |
| this.set("isHostListHidden", false); |
| this.set("isServiceListHidden", true); |
| } |
| }, |
| |
| /** |
| * force popup to show list of operations |
| */ |
| resetState: function(){ |
| if(this.get('parentView.isOpen')){ |
| this.set('isLogWrapHidden', true); |
| this.set('isTaskListHidden', true); |
| this.set('isHostListHidden', true); |
| this.set('isServiceListHidden', false); |
| this.get("controller").setBackgroundOperationHeader(false); |
| this.setOnStart(); |
| } |
| }.observes('parentView.isOpen'), |
| |
| /** |
| * When popup is opened, and data after polling has changed, update this data in component |
| */ |
| updateHostInfo: function () { |
| if(!this.get('parentView.isOpen')) return; |
| this.set('parentView.isLoaded', false); |
| this.get("controller").set("inputData", this.get("controller.dataSourceController.services")); |
| this.get("controller").onServiceUpdate(this.get('isServiceListHidden')); |
| this.get("controller").onHostUpdate(); |
| this.set('parentView.isLoaded', true); |
| //push hosts into view when none or all hosts are loaded |
| if(this.get('hosts') == null || this.get('hosts').length === this.get("controller.hosts").length){ |
| this.set("hosts", this.get("controller.hosts")); |
| } |
| this.set("services", this.get("controller.servicesInfo")); |
| }.observes("controller.dataSourceController.serviceTimestamp"), |
| |
| /** |
| * Depending on service filter, set which services should be shown |
| */ |
| visibleServices: function () { |
| if (this.get("services")) { |
| this.set("isServiceEmptyList", true); |
| if (this.get('serviceCategory.value')) { |
| var filter = this.get('serviceCategory.value'); |
| var services = this.get('services'); |
| this.set("isServiceEmptyList", this.setVisibility(filter, services)); |
| } |
| } |
| }.observes('serviceCategory', 'services', 'services.@each.status'), |
| |
| /** |
| * Depending on hosts filter, set which hosts should be shown |
| */ |
| visibleHosts: function () { |
| this.set("isHostEmptyList", true); |
| if (this.get('hostCategory.value') && this.get('hosts')) { |
| var filter = this.get('hostCategory.value'); |
| var hosts = this.get('hosts'); |
| this.set("isHostEmptyList", this.setVisibility(filter, hosts)); |
| } |
| }.observes('hostCategory', 'hosts', 'hosts.@each.status'), |
| |
| /** |
| * Depending on tasks filter, set which tasks should be shown |
| */ |
| visibleTasks: function () { |
| this.set("isTasksEmptyList", true); |
| if (this.get('taskCategory.value') && this.get('tasks')) { |
| var filter = this.get('taskCategory.value'); |
| var tasks = this.get('tasks'); |
| this.set("isTasksEmptyList", this.setVisibility(filter, tasks)); |
| } |
| }.observes('taskCategory', 'tasks', 'tasks.@each.status'), |
| |
| /** |
| * Depending on selected filter type, set object visibility value |
| * @param filter |
| * @param obj |
| * @return {Boolean} isEmptyList |
| */ |
| setVisibility: function (filter, obj) { |
| var isEmptyList = true; |
| if (filter == "all") { |
| obj.setEach("isVisible", true); |
| isEmptyList = !(obj.length > 0); |
| } else { |
| obj.forEach(function(item){ |
| if (filter == "pending") { |
| item.set('isVisible', ["pending", "queued"].contains(item.status)); |
| } else if (filter == "in_progress") { |
| item.set('isVisible', ["in_progress", "upgrading"].contains(item.status)); |
| } else if (filter == "failed") { |
| item.set('isVisible', (item.status === "failed")); |
| } else if (filter == "completed") { |
| item.set('isVisible', ["completed", "success"].contains(item.status)); |
| } else if (filter == "aborted") { |
| item.set('isVisible', (item.status === "aborted")); |
| } else if (filter == "timedout") { |
| item.set('isVisible', (item.status === "timedout")); |
| } |
| isEmptyList = (isEmptyList) ? !item.get('isVisible') : false; |
| }) |
| } |
| return isEmptyList; |
| }, |
| |
| /** |
| * Select box, display names and values |
| */ |
| categories: [ |
| categoryObject.create({value: 'all', labelPath: 'hostPopup.status.category.all'}), |
| categoryObject.create({value: 'pending', labelPath: 'hostPopup.status.category.pending'}), |
| categoryObject.create({value: 'in_progress', labelPath: 'hostPopup.status.category.inProgress'}), |
| categoryObject.create({value: 'failed', labelPath: 'hostPopup.status.category.failed'}), |
| categoryObject.create({value: 'completed', labelPath: 'hostPopup.status.category.success'}), |
| categoryObject.create({value: 'aborted', labelPath: 'hostPopup.status.category.aborted'}), |
| categoryObject.create({value: 'timedout', labelPath: 'hostPopup.status.category.timedout'}) |
| ], |
| |
| /** |
| * Selected option is binded to this values |
| */ |
| serviceCategory: null, |
| hostCategory: null, |
| taskCategory: null, |
| |
| /** |
| * Depending on currently viewed tab, call setSelectCount function |
| */ |
| updateSelectView: function () { |
| if (!this.get('isHostListHidden')) { |
| //since lazy loading used for hosts, we need to get hosts info directly from controller, that always contains entire array of data |
| this.get('controller').setSelectCount(this.get("controller.hosts"), this.get('categories')); |
| } else if (!this.get('isTaskListHidden')) { |
| this.get('controller').setSelectCount(this.get("tasks"), this.get('categories')); |
| } else if (!this.get('isServiceListHidden')) { |
| this.get('controller').setSelectCount(this.get("services"), this.get('categories')); |
| } |
| }.observes('tasks.@each.status', 'hosts.@each.status', 'isTaskListHidden', 'isHostListHidden', 'services.length', 'services.@each.status'), |
| |
| /** |
| * control data uploading, depending on which display level is showed |
| * @param levelName |
| */ |
| switchLevel: function (levelName) { |
| if (this.get("controller.isBackgroundOperations")) { |
| var BGController = App.router.get('backgroundOperationsController'); |
| var levelInfo = BGController.get('levelInfo'); |
| levelInfo.set('taskId', this.get('openedTaskId')); |
| levelInfo.set('requestId', this.get('controller.currentServiceId')); |
| levelInfo.set('name', levelName); |
| if (levelName === 'HOSTS_LIST') { |
| levelInfo.set('sync', (this.get('controller.hosts').length === 0)); |
| BGController.requestMostRecent(); |
| } else if (levelName === 'TASK_DETAILS') { |
| levelInfo.set('sync', true); |
| BGController.requestMostRecent(); |
| } else if (levelName === 'REQUESTS_LIST') { |
| this.get('controller.hosts').clear(); |
| BGController.requestMostRecent(); |
| } |
| } |
| }, |
| /** |
| * Onclick handler for button <-Tasks |
| * @param event |
| * @param context |
| */ |
| backToTaskList: function (event, context) { |
| this.destroyClipBoard(); |
| this.set("openedTaskId", 0); |
| this.set("isLogWrapHidden", true); |
| this.set("isTaskListHidden", false); |
| }, |
| |
| /** |
| * Onclick handler for button <-Hosts |
| * @param event |
| * @param context |
| */ |
| backToHostList: function (event, context) { |
| this.set("isHostListHidden", false); |
| this.set("isTaskListHidden", true); |
| this.set("tasks", null); |
| this.get("controller").set("popupHeaderName", this.get("controller.serviceName")); |
| this.switchLevel("HOSTS_LIST"); |
| }, |
| |
| /** |
| * Onclick handler for button <-Services |
| * @param event |
| * @param context |
| */ |
| backToServiceList: function (event, context) { |
| this.get("controller").set("serviceName", ""); |
| this.set("isHostListHidden", true); |
| this.set("isServiceListHidden", false); |
| this.set("isTaskListHidden", true); |
| this.set("tasks", null); |
| this.set("hosts", null); |
| this.get("controller").setBackgroundOperationHeader(false); |
| this.switchLevel("REQUESTS_LIST"); |
| }, |
| |
| /** |
| * Onclick handler for selected Service |
| * @param event |
| * @param context |
| */ |
| gotoHosts: function (event, context) { |
| this.get("controller").set("serviceName", event.context.get("name")); |
| this.get("controller").set("currentServiceId", event.context.get("id")); |
| this.get("controller").onHostUpdate(); |
| this.switchLevel("HOSTS_LIST"); |
| var servicesInfo = this.get("controller.hosts"); |
| if (servicesInfo.length) { |
| this.get("controller").set("popupHeaderName", event.context.get("name")); |
| } |
| //apply lazy loading on cluster with more than 100 nodes |
| if (servicesInfo.length > 100) { |
| this.set('hosts', servicesInfo.slice(0, 50)); |
| } else { |
| this.set('hosts', servicesInfo); |
| } |
| this.set("isServiceListHidden", true); |
| this.set("isHostListHidden", false); |
| $(".modal").scrollTop(0); |
| $(".modal-body").scrollTop(0); |
| if (servicesInfo.length > 100) { |
| Ember.run.next(this, function(){ |
| this.set('hosts', this.get('hosts').concat(servicesInfo.slice(50, servicesInfo.length))); |
| }); |
| } |
| }, |
| |
| /** |
| * Onclick handler for selected Host |
| * @param event |
| * @param context |
| */ |
| gotoTasks: function (event, context) { |
| var taskInfo = event.context.tasks; |
| if (taskInfo.length) { |
| this.get("controller").set("popupHeaderName", taskInfo.objectAt(0).hostName); |
| this.get("controller").set("currentHostName", taskInfo.objectAt(0).hostName); |
| } |
| this.switchLevel("TASKS_LIST"); |
| this.set('tasks', taskInfo); |
| this.set("isHostListHidden", true); |
| this.set("isTaskListHidden", false); |
| $(".modal").scrollTop(0); |
| $(".modal-body").scrollTop(0); |
| }, |
| |
| /** |
| * Onclick handler for selected Task |
| */ |
| openTaskLogInDialog: function () { |
| if ($(".task-detail-log-clipboard").length > 0) { |
| this.destroyClipBoard(); |
| } |
| var newWindow = window.open(); |
| var newDocument = newWindow.document; |
| newDocument.write($(".task-detail-log-info").html()); |
| newDocument.close(); |
| }, |
| |
| openedTaskId: 0, |
| |
| /** |
| * Return task detail info of opened task |
| */ |
| openedTask: function () { |
| if (!this.get('openedTaskId')) { |
| return Ember.Object.create(); |
| } |
| return this.get('tasks').findProperty('id', this.get('openedTaskId')); |
| }.property('tasks', 'tasks.@each.stderr', 'tasks.@each.stdout', 'openedTaskId'), |
| |
| /** |
| * Onclick event for show task detail info |
| * @param event |
| * @param context |
| */ |
| toggleTaskLog: function (event, context) { |
| var taskInfo = event.context; |
| this.set("isLogWrapHidden", false); |
| if ($(".task-detail-log-clipboard").length > 0) { |
| this.destroyClipBoard(); |
| } |
| this.set("isHostListHidden", true); |
| this.set("isTaskListHidden", true); |
| this.set('openedTaskId', taskInfo.id); |
| this.switchLevel("TASK_DETAILS"); |
| $(".modal").scrollTop(0); |
| $(".modal-body").scrollTop(0); |
| }, |
| |
| /** |
| * Onclick event for copy to clipboard button |
| * @param event |
| */ |
| textTrigger: function (event) { |
| if ($(".task-detail-log-clipboard").length > 0) { |
| this.destroyClipBoard(); |
| } else { |
| this.createClipBoard(); |
| } |
| }, |
| |
| /** |
| * Create Clip Board |
| */ |
| createClipBoard: function () { |
| $(".task-detail-log-clipboard-wrap").html('<textarea class="task-detail-log-clipboard"></textarea>'); |
| $(".task-detail-log-clipboard") |
| .html("stderr: \n" + $(".stderr").html() + "\n stdout:\n" + $(".stdout").html()) |
| .css("display", "block") |
| .width($(".task-detail-log-maintext").width()) |
| .height($(".task-detail-log-maintext").height()) |
| .select(); |
| $(".task-detail-log-maintext").css("display", "none") |
| }, |
| |
| /** |
| * Destroy Clip Board |
| */ |
| destroyClipBoard: function () { |
| $(".task-detail-log-clipboard").remove(); |
| $(".task-detail-log-maintext").css("display", "block"); |
| } |
| }) |
| })); |
| return self.get('isPopup'); |
| } |
| |
| }); |
| |
