ambari/ambari-web/app/views/common/host_progress_popup_body_view.js

/**
 * 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');
var batchUtils = require('utils/batch_scheduled_requests');
var date = require('utils/date/date');
var fileUtils = require('utils/file_utils');

/**
 * @typedef {object} TaskRelationObject
 * @property {string} type relation type 'service', 'component'
 * @property {string} [value] optional value of relation e.g. name of component or service
 */

/**
 * Option for "filter by state" dropdown
 * @typedef {object} progressPopupCategoryObject
 * @property {string} value "all|pending|in progress|failed|completed|aborted|timedout"
 * @property {number} count number of items with <code>state</code> equal to <code>this.value</code>
 * @property {string} labelPath key in the messages.js
 * @property {string} label localized label
 */
var categoryObject = Em.Object.extend({
  value: '',
  count: 0,
  labelPath: '',
  label: function () {
    return Em.I18n.t(this.get('labelPath')).format(this.get('count'));
  }.property('count', 'labelPath')
});

/**
 * @class HostProgressPopupBodyView
 * @type {Em.View}
 */
App.HostProgressPopupBodyView = App.TableView.extend({

  templateName: require('templates/common/host_progress_popup'),

  /**
   * @type {boolean}
   */
  showTextArea: false,

  /**
   * @type {boolean}
   */
  isServiceEmptyList: true,

  /**
   * @type {boolean}
   */
  isTasksEmptyList: true,

  /**
   * @type {number}
   */
  sourceRequestScheduleId: -1,

  /**
   * @type {boolean}
   */
  sourceRequestScheduleRunning: false,

  /**
   * @type {boolean}
   */
  sourceRequestScheduleAborted: false,

  /**
   * @type {?string}
   */
  sourceRequestScheduleCommand: null,

  /**
   * @type {string}
   */
  clipBoardContent: null,

  isClipBoardActive: false,

  /**
   * Determines that host information become loaded and mapped with <code>App.hostsMapper</code>.
   * This property play in only when Log Search service installed.
   *
   * @type {boolean}
   */
  hostInfoLoaded: true,

  /**
   * Alias for <code>controller.hosts</code>
   *
   * @type {wrappedHost[]}
   */
  hosts: function () {
    return this.get('controller.hosts')
  }.property('controller.hosts.[]'),

  /**
   * Alias for <code>controller.servicesInfo</code>
   *
   * @type {wrappedService[]}
   */
  services: function () {
    return this.get('controller.servicesInfo');
  }.property('controller.servicesInfo.[]'),

  /**
   * @type {number}
   */
  openedTaskId: 0,

  /**
   * Return task detail info of opened task
   *
   * @type {wrappedTask}
   */
  openedTask: function () {
    if (!(this.get('openedTaskId') && this.get('tasks'))) {
      return Em.Object.create();
    }
    return this.get('tasks').findProperty('id', this.get('openedTaskId'));
  }.property('tasks', 'tasks.@each.stderr', 'tasks.@each.stdout', 'openedTaskId'),

  /**
   * @type {object}
   */
  filterMap: {
    pending: ["pending", "queued"],
    in_progress: ["in_progress", "upgrading"],
    failed: ["failed"],
    completed: ["completed", "success"],
    aborted: ["aborted"],
    timedout: ["timedout"]
  },

  /**
   * Determines if "Show More ..."-link should be shown
   * @type {boolean}
   */
  isShowMore: true,

  /**
   * @type {boolean}
   */
  pagination: true,

  /**
   * @type {boolean}
   */
  isPaginate: false,

  /**
   * Select box, display names and values
   *
   * @type {progressPopupCategoryObject[]}
   */
  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 bound to this values
   * @type {?progressPopupCategoryObject}
   */
  serviceCategory: null,

  /**
   * @type {?progressPopupCategoryObject}
   */
  hostCategory: null,

  /**
   * @type {?progressPopupCategoryObject}
   */
  taskCategory: null,

  /**
   * flag to indicate whether level data has already been loaded
   * applied only to HOSTS_LIST and TASK_DETAILS levels, whereas async query used to obtain data
   *
   * @type {boolean}
   */
  isLevelLoaded: true,

  /**
   * <code>switchLevel</code> for some <code>controller.dataSourceController</code> should be customized
   * So, this map contains information about customize-methods
   * Format: key - <code>dataSourceController.name</code>, value - method name in this view
   * Method is called with same arguments as <code>switchLevel</code> is
   *
   * @type {object}
   */
  customControllersSwitchLevelMap: {
    highAvailabilityProgressPopupController: '_switchLevelForHAProgressPopupController'
  },

  /**
   * @type {boolean}
   */
  isHostEmptyList: Em.computed.empty('pageContent'),

  /**
   * @type {wrappedHost}
   */
  currentHost: function () {
    return this.get('hosts') && this.get('hosts').findProperty('name', this.get('controller.currentHostName'));
  }.property('controller.currentHostName'),

  /**
   * Tasks for current shown host (<code>currentHost</code>)
   *
   * @type {wrappedTask[]}
   */
  tasks: function () {
    var currentHost = this.get('currentHost');
    return currentHost ? currentHost.get('tasks') : [];
  }.property('currentHost.tasks', 'currentHost.tasks.@each.status'),


  /**
   * Message about aborting operation
   * Custom for Rolling Restart
   *
   * @type {string}
   */
  requestScheduleAbortLabel: function () {
    return 'ROLLING-RESTART' == this.get('sourceRequestScheduleCommand') ?
      Em.I18n.t("hostPopup.bgop.abort.rollingRestart"):
      Em.I18n.t("common.abort");
  }.property('sourceRequestScheduleCommand'),

  didInsertElement: function () {
    this.updateHostInfo();
    this.subscribeResize();
  },

  willDestroyElement: function () {
    if (this.get('controller.dataSourceController.name') == 'highAvailabilityProgressPopupController') {
      this.set('controller.dataSourceController.isTaskPolling', false);
    }
    this.unsubscribeResize();
  },

  /**
   * Subscribe for window <code>resize</code> event.
   *
   * @method subscribeResize
   */
  subscribeResize: function() {
    var self = this;
    $(window).on('resize', this.resizeHandler.bind(this));
    Em.run.next(this, function() {
      self.resizeHandler();
    });
  },

  /**
   * Remove event listener for window <code>resize</code> event.
   */
  unsubscribeResize: function() {
    $(window).off('resize', this.resizeHandler.bind(this));
  },

  /**
   * This method handles window resize and fit modal body content according to visible items for each <code>level</code>.
   *
   * @method resizeHandler
   */
  resizeHandler: function() {
    if (this.get('state') === 'destroyed' || !this.get('parentView.isOpen')) return;
    var headerHeight = 48,
        modalFooterHeight = 60,
        taskTopWrapHeight = 40,
        modalTopOffset = $('.modal').offset().top,
        contentPaddingBottom = 40,
        hostsPageBarHeight = 45,
        tabbedContentNavHeight = 68,
        logComponentFileNameHeight = 30,
        levelName = this.get('currentLevelName'),
        boLevelHeightMap = {
          'REQUESTS_LIST': {
            height: window.innerHeight - 2*modalTopOffset - headerHeight - taskTopWrapHeight - modalFooterHeight - contentPaddingBottom,
            target: '#service-info'
          },
          'HOSTS_LIST': {
            height: window.innerHeight - 2*modalTopOffset - headerHeight - taskTopWrapHeight - modalFooterHeight - contentPaddingBottom - hostsPageBarHeight,
            target: '#host-info'
          },
          'TASKS_LIST': {
            height: window.innerHeight - 2*modalTopOffset - headerHeight - taskTopWrapHeight - modalFooterHeight - contentPaddingBottom,
            target: '#host-log'
          },
          'TASK_DETAILS': {
            height: window.innerHeight - 2*modalTopOffset - headerHeight - taskTopWrapHeight - modalFooterHeight - contentPaddingBottom,
            target: ['.task-detail-log-info', '.log-tail-content.pre-styled']
          }
        },
        currentLevelHeight,
        resizeTarget;

    if (levelName && levelName in boLevelHeightMap) {
      resizeTarget = boLevelHeightMap[levelName].target;
      currentLevelHeight = boLevelHeightMap[levelName].height;
      if (levelName === 'TASK_DETAILS' && $('.task-detail-info').hasClass('task-detail-info-tabbed')) {
        currentLevelHeight -= tabbedContentNavHeight;
      }
      if (!Em.isArray(resizeTarget)) {
        resizeTarget = [resizeTarget];
      }
      resizeTarget.forEach(function(target) {
        if (target === '.log-tail-content.pre-styled') {
          currentLevelHeight -= logComponentFileNameHeight;
        }
        $(target).css('maxHeight', currentLevelHeight + 'px');
      });
    }
  },

  currentLevelName: function() {
    return this.get('controller.dataSourceController.levelInfo.name');
  }.property('controller.dataSourceController.levelInfo.name'),

  /**
   * Preset values on init
   *
   * @method setOnStart
   */
  setOnStart: function () {
    this.set('serviceCategory', this.get('categories').findProperty('value', 'all'));
    if (this.get("controller.isBackgroundOperations")) {
      this.get('controller').setSelectCount(this.get("services"), this.get('categories'));
      this.updateHostInfo();
    }
    else {
      this.set("parentView.isHostListHidden", false);
      this.set("parentView.isServiceListHidden", true);
    }
  },

  /**
   * force popup to show list of operations
   *
   * @method resetState
   */
  resetState: function () {
    if (this.get('parentView.isOpen')) {
      this.get('parentView').setProperties({
        isLogWrapHidden: true,
        isTaskListHidden: true,
        isHostListHidden: true,
        isServiceListHidden: false
      });
      this.get("controller").setBackgroundOperationHeader(false);
      this.get('controller.hosts').clear();
      this.setOnStart();
      this.rerender();
    }
  }.observes('parentView.isOpen'),

  /**
   * When popup is opened, and data after polling has changed, update this data in component
   *
   * @method updateHostInfo
   */
  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('parentView.isServiceListHidden'));
    this.get("controller").onHostUpdate();
    this.set('parentView.isLoaded', true);
    this.set("hosts", this.get("controller.hosts"));
    this.set("services", this.get("controller.servicesInfo"));
    this.set('isLevelLoaded', true);
  }.observes("controller.dataSourceController.serviceTimestamp"),

  /**
   * Depending on service filter, set which services should be shown
   *
   * @method visibleServices
   */
  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
   *
   * @method filter
   */
  filter: function () {
    var filter = this.get('hostCategory.value');
    var hosts = this.get('hosts') || [];
    var filterMap = this.get('filterMap');
    if (!filter || !hosts.length) {
      return;
    }
    if (filter === 'all') {
      this.set('filteredContent', hosts);
    }
    else {
      this.set('filteredContent', hosts.filter(function (item) {
        return filterMap[filter].contains(item.status);
      }));
    }
  }.observes('hosts.length', 'hostCategory.value'),

  /**
   * Reset startIndex property back to 1 when filter type has been changed.
   *
   * @method resetIndex
   */
  resetIndex: function () {
    if (this.get('hostCategory.value')) {
      this.set('startIndex', 1);
    }
  }.observes('hostCategory.value'),

  /**
   * Depending on tasks filter, set which tasks should be shown
   *
   * @method visibleTasks
   */
  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 {bool} isEmptyList
   * @method setVisibility
   */
  setVisibility: function (filter, obj) {
    var isEmptyList = true;
    var filterMap = this.get('filterMap');
    if (filter == "all") {
      obj.setEach("isVisible", true);
      isEmptyList = !obj.length;
    }
    else {
      obj.forEach(function (item) {
        item.set('isVisible', filterMap[filter].contains(item.status));
        isEmptyList = (isEmptyList) ? !item.get('isVisible') : false;
      }, this)
    }
    return isEmptyList;
  },

  /**
   * Depending on currently viewed tab, call setSelectCount function
   *
   * @method updateSelectView
   */
  updateSelectView: function () {
    var isPaginate;
    if (this.get('parentView.isHostListHidden')) {
      if (this.get('parentView.isTaskListHidden')) {
        if (!this.get('parentView.isServiceListHidden')) {
          this.get('controller').setSelectCount(this.get("services"), this.get('categories'));
        }
      }
      else {
        this.get('controller').setSelectCount(this.get("tasks"), this.get('categories'));
      }
    }
    else {
      //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'));
      isPaginate = true;

    }
    this.set('isPaginate', !!isPaginate);
  }.observes('tasks.@each.status', 'hosts.@each.status', 'parentView.isTaskListHidden', 'parentView.isHostListHidden', 'services.length', 'services.@each.status'),

  /**
   * control data uploading, depending on which display level is showed
   *
   * @param {string} levelName
   * @method switchLevel
   */
  switchLevel: function (levelName) {
    var dataSourceController = this.get('controller.dataSourceController');
    var args = [].slice.call(arguments);
    this.get('hostComponentLogs').clear();
    if (this.get("controller.isBackgroundOperations")) {
      var levelInfo = dataSourceController.get('levelInfo');
      levelInfo.set('taskId', this.get('openedTaskId'));
      levelInfo.set('requestId', this.get('controller.currentServiceId'));
      levelInfo.set('name', levelName);
      if (levelName === 'HOSTS_LIST') {
        this.set('isLevelLoaded', dataSourceController.requestMostRecent());
        this.set('hostCategory', this.get('categories').findProperty('value', 'all'));
      }
      else {
        if (levelName === 'TASK_DETAILS') {
          dataSourceController.requestMostRecent();
          this.set('isLevelLoaded', false);
        }
        else {
          if (levelName === 'REQUESTS_LIST') {
            this.set('serviceCategory', this.get('categories').findProperty('value', 'all'));
            this.get('controller.hosts').clear();
            dataSourceController.requestMostRecent();
          }
          else {
            this.set('taskCategory', this.get('categories').findProperty('value', 'all'));
          }
        }
      }
    }
    else {
      var customControllersSwitchLevelMap = this.get('customControllersSwitchLevelMap');
      Em.tryInvoke(this, customControllersSwitchLevelMap[dataSourceController.get('name')], args);
    }
  },

  levelDidChange: function() {
    var levelName = this.get('controller.dataSourceController.levelInfo.name'),
        self = this;

    if (levelName && this.get('isLevelLoaded')) {
      Em.run.next(this, function() {
        self.resizeHandler();
      });
    }
  }.observes('controller.dataSourceController.levelInfo.name', 'isLevelLoaded'),


  popupIsOpenDidChange: function() {
    if (!this.get('isOpen')) {
      this.get('hostComponentLogs').clear();
    }
  }.observes('parentView.isOpen'),

  /**
   * Switch-level custom method for <code>highAvailabilityProgressPopupController</code>
   *
   * @param {string} levelName
   * @private
   */
  _switchLevelForHAProgressPopupController: function (levelName) {
    var dataSourceController = this.get('controller.dataSourceController');
    if (levelName === 'TASK_DETAILS') {
      this.set('isLevelLoaded', false);
      dataSourceController.startTaskPolling(this.get('openedTask.request_id'), this.get('openedTask.id'));
      Em.keys(this.get('parentView.detailedProperties')).forEach(function (key) {
        dataSourceController.addObserver('taskInfo.' + this.get('parentView.detailedProperties')[key], this, 'updateTaskInfo');
      }, this);
    }
    else {
      dataSourceController.stopTaskPolling();
    }
  },

  /**
   * @method updateTaskInfo
   */
  updateTaskInfo: function () {
    var dataSourceController = this.get('controller.dataSourceController');
    var openedTask = this.get('openedTask');
    if (openedTask && openedTask.get('id') == dataSourceController.get('taskInfo.id')) {
      this.set('isLevelLoaded', true);
      Em.keys(this.get('parentView.detailedProperties')).forEach(function (key) {
        openedTask.set(key, dataSourceController.get('taskInfo.' + key));
      }, this);
    }
  },

  /**
   * Onclick handler for button <-Tasks
   *
   * @method backToTaskList
   */
  backToTaskList: function () {
    this.destroyClipBoard();
    this.set("openedTaskId", 0);
    this.set("parentView.isLogWrapHidden", true);
    this.set("parentView.isTaskListHidden", false);
    this.switchLevel("TASKS_LIST");
  },

  /**
   * Onclick handler for button <-Hosts
   *
   * @method backToHostList
   */
  backToHostList: function () {
    this.set("parentView.isHostListHidden", false);
    this.set("parentView.isTaskListHidden", true);
    this.get("controller").set("popupHeaderName", this.get("controller.serviceName"));
    this.get("controller").set("operationInfo", this.get('controller.servicesInfo').findProperty('name', this.get('controller.serviceName')));
    this.switchLevel("HOSTS_LIST");
  },

  /**
   * Onclick handler for button <-Services
   *
   * @method backToServiceList
   */
  backToServiceList: function () {
    this.get("controller").set("serviceName", "");
    this.set("parentView.isHostListHidden", true);
    this.set("parentView.isServiceListHidden", false);
    this.set("parentView.isTaskListHidden", true);
    this.set("parentView.isLogWrapHidden", true);
    this.set("hosts", null);
    this.get("controller").setBackgroundOperationHeader(false);
    this.switchLevel("REQUESTS_LIST");
  },

  /**
   * Onclick handler for Show more ..
   *
   * @method requestMoreOperations
   */
  requestMoreOperations: function () {
    var BGOController = App.router.get('backgroundOperationsController');
    var count = BGOController.get('operationsCount');
    BGOController.set('operationsCount', (count + 10));
    BGOController.requestMostRecent();
  },

  /**
   * @method setShowMoreAvailable
   */
  setShowMoreAvailable: function () {
    if (this.get('parentView.isOpen')) {
      this.set('isShowMore', App.router.get("backgroundOperationsController.isShowMoreAvailable"));
    }
  }.observes('parentView.isOpen', 'App.router.backgroundOperationsController.isShowMoreAvailable'),

  /**
   * Onclick handler for selected Service
   *
   * @param {{context: wrappedService}} event
   * @method gotoHosts
   */
  gotoHosts: function (event) {
    this.get("controller").set("serviceName", event.context.get("name"));
    this.get("controller").set("currentServiceId", event.context.get("id"));
    this.get("controller").set("currentHostName", null);
    this.get("controller").onHostUpdate();
    this.switchLevel("HOSTS_LIST");
    var servicesInfo = this.get("controller.hosts");
    this.set("controller.popupHeaderName", event.context.get("name"));
    this.set("controller.operationInfo", event.context);

    //apply lazy loading on cluster with more than 100 nodes
    this.set('hosts', servicesInfo.length > 100 ? servicesInfo.slice(0, 50) : servicesInfo);
    this.set("parentView.isServiceListHidden", true);
    this.set("parentView.isHostListHidden", false);
    this.set("parentView.isTaskListHidden", true);
    $(".modal").scrollTop(0);
    $(".modal-body").scrollTop(0);
    if (servicesInfo.length > 100) {
      Em.run.next(this, function () {
        this.set('hosts', this.get('hosts').concat(servicesInfo.slice(50, servicesInfo.length)));
      });
    }
    // Determine if source request schedule is present
    this.set('sourceRequestScheduleId', event.context.get("sourceRequestScheduleId"));
    this.set('sourceRequestScheduleCommand', event.context.get('contextCommand'));
    this.refreshRequestScheduleInfo();
  },

  /**
   * Navigate to host details logs tab with preset filter.
   */
  navigateToHostLogs: function() {
    var relationType = this._determineRoleRelation(this.get('openedTask')),
        hostModel = App.Host.find().findProperty('hostName', this.get('openedTask.hostName')),
        queryParams = [],
        model;

    if (relationType.type === 'component') {
      model = App.StackServiceComponent.find().findProperty('componentName', relationType.value);
      queryParams.push('service_name=' + model.get('serviceName'));
      queryParams.push('component_name=' + relationType.value);
    }
    if (relationType.type === 'service') {
      queryParams.push('service_name=' + relationType.value);
    }
    App.router.transitionTo('main.hosts.hostDetails.logs', hostModel, { query: ''});
    if (this.get('parentView') && typeof this.get('parentView').onClose === 'function') this.get('parentView').onClose();
  },

  /**
  /**
  * Determines if opened task related to service or component.
  *
  * @return {boolean} <code>true</code> when relates to service or component
  */
  isLogsLinkVisible: function() {
    if (!this.get('openedTask') || !this.get('openedTask.id')) return false;
    return !!this._determineRoleRelation(this.get('openedTask'));
  }.property('openedTask'),

  /**
   * @param  {wrappedTask} taskInfo
   * @return {boolean|TaskRelationObject}
   */
  _determineRoleRelation: function(taskInfo) {
    var foundComponentName,
        foundServiceName,
        componentNames = App.StackServiceComponent.find().mapProperty('componentName'),
        serviceNames = App.StackService.find().mapProperty('serviceName'),
        taskLog = this.get('currentHost.logTasks').findProperty('Tasks.id', Em.get(taskInfo, 'id')) || {},
        role = Em.getWithDefault(taskLog, 'Tasks.role', false),
        eqlFn = function(compare) {
          return function(item) {
            return item === compare;
          };
        };

    if (!role) {
      return false;
    }
    // component service check
    if (role.endsWith('_SERVICE_CHECK')) {
      role = role.replace('_SERVICE_CHECK', '');
    }
    foundComponentName = componentNames.filter(eqlFn(role))[0];
    foundServiceName = serviceNames.filter(eqlFn(role))[0];
    if (foundComponentName || foundServiceName) {
      return {
        type: foundComponentName ? 'component' : 'service',
        value: foundComponentName || foundServiceName
      }
    }
    return false;
  },

  /**
   * @type {boolean}
   */
  isRequestSchedule: function () {
    var id = this.get('sourceRequestScheduleId');
    return id != null && !isNaN(id) && id > -1;
  }.property('sourceRequestScheduleId'),

  /**
   * @method refreshRequestScheduleInfo
   */
  refreshRequestScheduleInfo: function () {
    var self = this;
    var id = this.get('sourceRequestScheduleId');
    batchUtils.getRequestSchedule(id, function (data) {
      var status = Em.get(data || {}, 'RequestSchedule.status');
      if (status) {
        switch (status) {
          case 'DISABLED':
            self.set('sourceRequestScheduleRunning', false);
            self.set('sourceRequestScheduleAborted', true);
            break;
          case 'COMPLETED':
            self.set('sourceRequestScheduleRunning', false);
            self.set('sourceRequestScheduleAborted', false);
            break;
          case 'SCHEDULED':
            self.set('sourceRequestScheduleRunning', true);
            self.set('sourceRequestScheduleAborted', false);
            break;
        }
      }
      else {
        self.set('sourceRequestScheduleRunning', false);
        self.set('sourceRequestScheduleAborted', false);
      }
    }, function () {
      self.set('sourceRequestScheduleRunning', false);
      self.set('sourceRequestScheduleAborted', false);
    });
  }.observes('sourceRequestScheduleId'),

  /**
   * Attempts to abort the current request schedule
   *
   * @param {{context: number}} event
   * @method doAbortRequestSchedule
   */
  doAbortRequestSchedule: function (event) {
    var self = this;
    var id = event.context;
    batchUtils.doAbortRequestSchedule(id, function () {
      self.refreshRequestScheduleInfo();
    });
  },

  /**
   * Onclick handler for selected Host
   *
   * @param {{context: wrappedHost}} event
   * @method gotoTasks
   */
  gotoTasks: function (event) {
    var tasksInfo = [];
    event.context.logTasks.forEach(function (_task) {
      tasksInfo.pushObject(this.get("controller").createTask(_task));
    }, this);
    if (tasksInfo.length) {
      this.get("controller").set("popupHeaderName", event.context.publicName);
      this.get("controller").set("currentHostName", event.context.publicName);
    }
    this.switchLevel("TASKS_LIST");
    this.set('currentHost.tasks', tasksInfo);
    this.set("parentView.isHostListHidden", true);
    this.set("parentView.isTaskListHidden", false);
    this.preloadHostModel(Em.getWithDefault(event.context || {}, 'name', false));
    $(".modal").scrollTop(0);
    $(".modal-body").scrollTop(0);
  },

  /**
   * Will add <code>App.Host</code> model with relevant host info by specified host name only when it missed
   * and Log Search service installed.
   * This update needed to get actual status of logs for components located on this host and get appropriate model
   * for navigation to hosts/:host_id/logs route.
   *
   * @method preloadHostModel
   * @param {string} hostName host name to get info
   */
  preloadHostModel: function(hostName) {
    var self = this,
        fields;
    if (!hostName) {
      self.set('hostInfoLoaded', true);
      return;
    }
    if (this.get('isLogSearchInstalled') && App.get('supports.logSearch') && !App.Host.find().someProperty('hostName', hostName)) {
      this.set('hostInfoLoaded', false);
      fields = ['stack_versions/repository_versions/RepositoryVersions/repository_version',
                'host_components/HostRoles/host_name'];
      App.router.get('updateController').updateLogging(hostName, fields, function(data) {
        App.hostsMapper.map({ items: [data] });
      }).always(function() {
        self.set('hostInfoLoaded', true);
      });
    } else {
      self.set('hostInfoLoaded', true);
    }
  },

  /**
   * @method stopRebalanceHDFS
   * @returns {App.ModalPopup}
   */
  stopRebalanceHDFS: function () {
    var hostPopup = this;
    return App.showConfirmationPopup(function () {
      App.ajax.send({
        name: 'cancel.background.operation',
        sender: hostPopup,
        data: {
          requestId: hostPopup.get('controller.currentServiceId')
        }
      });
      hostPopup.backToServiceList();
    });
  },

  /**
   * Onclick handler for selected Task
   *
   * @method openTaskLogInDialog
   */
  openTaskLogInDialog: function () {
    var target = ".task-detail-log-info",
        activeHostLog = this.get('hostComponentLogs').findProperty('isActive', true),
        activeHostLogSelector = activeHostLog ? activeHostLog.get('tabClassNameSelector') + '.active' : false;

    if ($(".task-detail-log-clipboard").length) {
      this.destroyClipBoard();
    }
    if (activeHostLog && $(activeHostLogSelector).length) {
      target = activeHostLogSelector;
    }
    var newWindow = window.open();
    var newDocument = newWindow.document;
    newDocument.write($(target).html());
    newDocument.close();
  },

  /**
   * Onclick event for show task detail info
   *
   * @param {{context: wrappedTask}} event
   * @method toggleTaskLog
   */
  toggleTaskLog: function (event) {
    var taskInfo = event.context;
    this.set("parentView.isLogWrapHidden", false);
    if ($(".task-detail-log-clipboard").length) {
      this.destroyClipBoard();
    }
    this.set("parentView.isHostListHidden", true);
    this.set("parentView.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
   *
   * @method textTrigger
   */
  textTrigger: function () {
    $(".task-detail-log-clipboard").length ? this.destroyClipBoard() : this.createClipBoard();
  },

  /**
   * Create Clip Board
   *
   * @method createClipBoard
   */
  createClipBoard: function () {
    var isLogComponentActive = this.get('hostComponentLogs').someProperty('isActive', true),
        logElement = isLogComponentActive ? $('.log-component-tab.active .log-tail-content'): $(".task-detail-log-maintext"),
        logElementRect = logElement[0].getBoundingClientRect(),
        clipBoardContent = this.get('clipBoardContent');
    $(".task-detail-log-clipboard-wrap").html('<textarea class="task-detail-log-clipboard"></textarea>');
    $(".task-detail-log-clipboard")
      .html(isLogComponentActive ? this.get('clipBoardContent') : "stderr: \n" + $(".stderr").html() + "\n stdout:\n" + $(".stdout").html())
      .css('display', 'block')
      .width(logElementRect.width)
      .height(isLogComponentActive ? logElement[0].scrollHeight : logElementRect.height)
      .select();

    this.set('isClipBoardActive', true);
  },

  /**
   * Destroy Clip Board
   *
   * @method destroyClipBoard
   */
  destroyClipBoard: function () {
    var logElement = this.get('hostComponentLogs').someProperty('isActive', true) ? $('.log-component-tab.active .log-tail-content'): $(".task-detail-log-maintext");

    $(".task-detail-log-clipboard").remove();
    logElement.css("display", "block");
    this.set('isClipBoardActive', false);
  },

  isLogSearchInstalled: function() {
    return App.Service.find().someProperty('serviceName', 'LOGSEARCH');
  }.property(),

  /**
   * Host component logs associated with selected component on 'TASK_DETAILS' level.
   *
   * @property {object[]}
   */
  hostComponentLogs: function() {
    var relationType,
        componentName,
        hostName,
        logFile,
        linkTailTpl = '?host_name={0}&file_name={1}&component_name={2}',
        self = this;

    if (this.get('openedTask.id')) {
      relationType = this._determineRoleRelation(this.get('openedTask'));
      if (relationType.type === 'component') {
        hostName = this.get('currentHost.name');
        componentName = relationType.value;
        return App.HostComponentLog.find()
          .filterProperty('hostComponent.host.hostName', hostName)
          .filterProperty('hostComponent.componentName', componentName)
          .reduce(function(acc, item, index) {
            var serviceName = item.get('hostComponent.service.serviceName'),
                logComponentName = item.get('name'),
                componentHostName = item.get('hostComponent.host.hostName');
            acc.pushObjects(item.get('logFileNames').map(function(logFileName, idx) {
              var tabClassName = logComponentName + '_' + index + '_' + idx;
              return Em.Object.create({
                hostName: componentHostName,
                logComponentName: logComponentName,
                fileName: logFileName,
                tabClassName: tabClassName,
                tabClassNameSelector: '.' + tabClassName,
                displayedFileName: fileUtils.fileNameFromPath(logFileName),
                linkTail: linkTailTpl.format(hostName, logFileName, logComponentName),
                isActive: false
              });
            }));
            return acc;
          }, []);
      }
    }
    return [];
  }.property('openedTaskId', 'isLevelLoaded'),

  /**
   * Determines if there are component logs for selected component within 'TASK_DETAILS' level.
   *
   * @property {boolean}
   */
  hostComponentLogsExists: function() {
    return this.get('isLogSearchInstalled') && !!this.get('hostComponentLogs.length') && this.get('parentView.isOpen');
  }.property('hostComponentLogs.length', 'isLogSearchInstalled', 'parentView.isOpen'),

  /**
   * Minimum required content to embed in App.LogTailView. This property observes current active host component log.
   *
   * @property {object}
   */
  logTailViewContent: function() {
    if (!this.get('hostComponentLog')) {
      return null;
    }
    return Em.Object.create({
      hostName: this.get('currentHost.name'),
      logComponentName: this.get('hostComponentLog.name')
    });
  }.property('hostComponentLogs.@each.isActive'),

  logTailView: App.LogTailView.extend({

    isActiveDidChange: function() {
      var self = this;
      if (this.get('content.isActive') === false) return;
      setTimeout(function() {
        self.scrollToBottom();
        self.storeToClipBoard();
      }, 500);
    }.observes('content.isActive'),

    logRowsLengthDidChange: function() {
      if (!this.get('content.isActive') || this.get('state') === 'destroyed') return;
      this.storeToClipBoard();
    }.observes('logRows.length'),

    /**
     * Stores log content to use for clip board.
     */
    storeToClipBoard: function() {
      this.get('parentView').set('clipBoardContent', this.get('logRows').map(function(i) {
        return i.get('logtimeFormatted') + ' ' + i.get('level') + ' ' + i.get('logMessage');
      }).join('\n'));
    }
  }),

  setActiveLogTab: function(e) {
    var content = e.context;
    this.set('clipBoardContent', null);
    this.get('hostComponentLogs').without(content).setEach('isActive', false);
    if (this.get('isClipBoardActive')) {
      this.destroyClipBoard();
    }
    content.set('isActive', true);
  },

  setActiveTaskLogTab: function() {
    this.set('clipBoardContent', null);
    this.get('hostComponentLogs').setEach('isActive', false);
    if (this.get('isClipBoardActive')) {
      this.destroyClipBoard();
    }
  }
});