foreman_wreckingball 3.0.1 → 3.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d61b28b92f7f4ed29367841c4bec7b80ea38cc4610daf6e4ec78f1181ac8b5c9
-  data.tar.gz: 89f264e68c658e9135a07f761584f23e51b543ba8264bb4a0ead2aef132449b5
+  metadata.gz: 5386e48704b4c0837fd34063239ead1bda9c7e2dd72cc60d82c15ac60334fea2
+  data.tar.gz: 4ed751665783de1efb8e25534cc32324f287c4611aa579d031873078b53ff7d1
 SHA512:
-  metadata.gz: 0e24c4e6c7ad4cd4eb6bb6f6e66a18712bc090fb41f60d0b639448b9763aad0655aa49a4f80206b036b25fc70d9acae8319a5d027becb8f43d6a26263152232a
-  data.tar.gz: 76271354a6bd79fd6263bca07ffdc8cba779b1be3ad9744f0675bc5b80c4498c214c473d2b7825af3af5f73d0f20def793bceeffcecfd784f8e0d78f2e6c8a20
+  metadata.gz: 2d6df272535f83e43c0889bce9655beb8b01f522269a85ebfbb7e5a6f1d332c407632e295234e12e7dc826897e8cc7eda587a322a57d265b3239ebbda54b4d4f
+  data.tar.gz: 3aea63d70aa6895ba153fdf32c370127ca8ee8a2b22ceb9099b4c8ded6fca3b8315561e4cd78854ec1977b6df73d7dee7e54e5943237de496dfaf1eebec179bd

data/README.md

@@ -1,5 +1,7 @@
 # ForemanWreckingball
 
+[<img src="https://opensourcelogos.aws.dmtech.cloud/dmTECH_opensource_logo%401x.svg" height="21" width="130">](https://www.dmtech.de/)
+
 This is a plugin for Foreman that adds several VMware related status checks to your Hosts in Foreman. For performance reasons, these checks are only run periodically.
 
 ## Compatibility
@@ -23,7 +25,7 @@ Fork and send a Pull Request. Thanks!
 
 ## Copyright
 
-Copyright (c) 2018 dm-drogerie markt GmbH & Co. KG https://dm.de
+Copyright (c) 2018 dmTECH GmbH, [dmtech.de](https://www.dmtech.de/)
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by

data/app/assets/javascripts/foreman_wreckingball/modal.js

@@ -9,29 +9,38 @@ function submit_modal_form() {
   $('#confirmation-modal').modal('hide');
 }
 
-function show_modal(element, url) {
-  if (!url) {
-    url = $(element).attr('href');    
-  }
-  var title = $(element).attr('data-title');
-  if (title) {
-    $('#confirmation-modal .modal-title').text(title);
-  }
+function show_modal(element) {
+  if ($(element).attr('disabled')) { return; }
+
+  const url = $(element).attr('href');
+  const title = $(element).data('title');
+  const hostAssociation = $(element).data('host-association');
+
+  if (title) { $('#confirmation-modal .modal-title').text(title); }
+
   $('#confirmation-modal .modal-body')
     .empty()
     .append('<div class="modal-spinner spinner spinner-lg"></div>');
   $('#confirmation-modal').modal();
-  $('#confirmation-modal .modal-body').load(url + ' #content',
-    function(response, status, xhr) {
-      $('#confirmation-modal .form-actions').remove();
 
-      var submit_button = $('#confirmation-modal button[data-action="submit"]');
-      if ($(element).attr('data-submit-class')) {
-        submit_button.attr('class', 'btn ' + $(element).attr('data-submit-class'));
-      } else {
-        submit_button.attr('class', 'btn btn-primary');
-      }
+  let params;
+  if (!!hostAssociation) {
+    params = Object.assign({}, { host_association: hostAssociation },
+      !!$(element).data('owned-only') ? { owned_only: true } : null);
+  } else if($(element).data('status-id')) {
+    params = { status_ids: [$(element).data('status-id')] };
+  } else {
+    const statusIds = $(element).closest('.status-row')
+      .find(':checkbox[name="status-id"]:checked')
+      .map((_, e) => { return e.value; })
+      .toArray();
+    params = { status_ids: statusIds };
+  }
 
+  $('#confirmation-modal .modal-body').load(`${url}?${$.param(params)} #content`,
+    (response, status, xhr) => {
+      $('#confirmation-modal .form-actions').remove();
+      $('#confirmation-modal button[data-action="submit"]').attr('class', 'btn btn-primary');
       $('#confirmation-modal a[rel="popover"]').popover();
 
       trigger_form_selector_binds('schedule_remediate_form', url);
@@ -39,4 +48,3 @@ function show_modal(element, url) {
     });
   return false;
 }
-

data/app/assets/javascripts/foreman_wreckingball/status_hosts_table.js

@@ -0,0 +1,81 @@
+$(document).ready(() => {
+  $.fn.dataTable.ext.errMode = 'none';
+  $('.status-row.list-group-item').one('click', function() {
+    $(this).find('table.status-hosts').each((_index, element) => {
+      $(element).dataTable({
+        searching: false,
+        ordering: false,
+        bLengthChange: false,
+        lengthMenu: [100],
+        processing: true,
+        serverSide: true,
+        columnDefs: [
+          { className: 'ellipsis', targets: [1, 2, 3, 4] },
+          { width: '10px', targets: 0 }
+        ],
+        ajax: {
+          url: $(element).data('hosts-url'),
+          type: 'GET',
+          data: (_, oSettings) => {
+            const { _iDisplayStart: start, _iDisplayLength: perPage } = oSettings;
+            const page = (start / perPage) + 1;
+            return {
+              page: page || 1,
+              per_page: perPage
+            };
+          },
+          dataSrc: (json) => {
+            return json.data.map((e) => {
+              let row = [
+                `<input name='status-id' type='checkbox' value='${e.status.id}' data-remediate='${!!e.remediate}' >`,
+                `<a href="${e.path}">${e.name}</a>`,
+                `<span class="${e.status.icon_class}"></span><span class="${e.status.status_class}">${e.status.label}</span>`,
+                (e.owner || {}).name || '',
+                (e.environment || {}).name || ''
+              ];
+              if(e.remediate) {
+                row.push(`
+                  <span class="btn btn-sm btn-default">
+                    <a data-title="${e.remediate.title}"
+                       data-id="aid_wreckingball_hosts_${e.name}_schedule_remediate"
+                       data-status-id="${e.status.id}"
+                       onclick="show_modal(this); return false;"
+                       href="${e.remediate.path}">
+                         ${e.remediate.label}
+                    </a>
+                  </span>`);
+              } else {
+                row.push(null);
+              }
+              return row;
+            });
+          }
+        }
+      });
+      $(element).on('error.dt', (_, settings) => {
+        $(settings.nTable).closest('.status-hosts-container').addClass('ajax-error');
+      });
+      $(element).on('page.dt', () => {
+        $selectAll.prop('checked', false).change();
+        $remediateSelected.attr('disabled', true);
+      });
+
+      const $selectAll = $(this).find(':checkbox[name="select-all"]');
+      const $remediateSelected = $(this).find('a.remediate-selected');
+
+      $selectAll.prop('checked', false);
+
+      $selectAll.change(() => {
+        const $selectHost = $(this).find(':checkbox[name="status-id"]');
+        $selectHost.prop('checked', $selectAll.is(':checked'));
+        $remediateSelected.attr('disabled', !$selectAll.is(':checked'));
+      });
+
+      $(this).on('change', ':checkbox[name=status-id]', () => {
+        const isAnyHostChecked = $(this).find(':checkbox[name="status-id"]').is(':checked');
+        $selectAll.prop('checked', isAnyHostChecked);
+        $remediateSelected.attr('disabled', !isAnyHostChecked);
+      });
+    });
+  });
+});

data/app/assets/javascripts/foreman_wreckingball/status_managed_hosts_dashboard.js

@@ -0,0 +1,14 @@
+$(document).ready(() => {
+  $('table#missing_vms').add('table#wrong_hosts').add('table#more_than_one_hosts')
+    .DataTable({
+      bLengthChange: true,
+      lengthMenu: [20, 50, 100],
+      order: [[ 0, 'desc' ]],
+      columnDefs: [
+        {
+          'targets': 'no-sort',
+          'orderable': false,
+        }
+      ]
+    });
+});

data/app/assets/javascripts/foreman_wreckingball/status_row.js

@@ -0,0 +1,17 @@
+$(document).ready(() => {
+  // click the list-view heading then expand a row
+  $('.list-group-item-header').click(function(event) {
+    if(!$(event.target).is('button, a, input, .fa-ellipsis-v')) {
+      $(this).find('.fa-angle-right').toggleClass('fa-angle-down')
+        .end().parent().toggleClass('list-view-pf-expand-active')
+        .find('.list-group-item-container').toggleClass('hidden');
+    }
+  });
+
+  // click the close button, hide the expand row and remove the active status
+  $('.list-group-item-container .close').click(function() {
+    $(this).parent().addClass('hidden')
+      .parent().removeClass('list-view-pf-expand-active')
+      .find('.fa-angle-right').removeClass('fa-angle-down');
+  });
+});

data/app/assets/stylesheets/foreman_wreckingball/status_hosts_table.css.scss

@@ -0,0 +1,13 @@
+div.status-hosts-container div.alert-danger {
+  display: none;
+}
+
+div.status-hosts-container.ajax-error div.alert-danger {
+  margin-top: 25px;
+  display: block;
+}
+
+div.status-hosts-container.ajax-error div.dataTables_wrapper,
+div.status-hosts-container.ajax-error p {
+  display: none;
+}

data/app/assets/stylesheets/foreman_wreckingball/status_managed_hosts_dashboard.css.scss

@@ -0,0 +1,8 @@
+.status-managed-hosts-dashboard-cards {
+  .card-pf.card-pf-accented.card-pf-aggregate-status {
+    min-height: 100px;
+    .card-pf-title {
+      min-height: 30px;
+    }
+  }
+}

data/app/controllers/foreman_wreckingball/hosts_controller.rb

@@ -3,45 +3,125 @@
 module ForemanWreckingball
   class HostsController < ::HostsController
     include ::ForemanTasks::Concerns::Parameters::Triggering
-    before_action :find_resource, :only => [:submit_remediate, :schedule_remediate]
-    before_action :find_status, :only => [:submit_remediate, :schedule_remediate]
+    include ::HostsHelper
+    include ::AuthorizeHelper
+
+    AJAX_REQUESTS = [:status_hosts].freeze
+    before_action :ajax_request, :only => AJAX_REQUESTS
+    before_action :find_statuses, :only => [:schedule_remediate, :submit_remediate]
 
     def status_dashboard
-      statuses = [
-        ToolsStatus,
-        OperatingsystemStatus,
-        CpuHotAddStatus,
-        SpectreV2Status
-      ]
-
-      @newest_data = Host.authorized(:view_hosts, Host).joins(:vmware_facet).maximum('vmware_facets.updated_at')
-
-      @data = statuses.map do |status|
-        host_association = status.host_association
-        hosts = Host.authorized(:view_hosts, Host)
-                    .joins(host_association)
-                    .includes(host_association)
-                    .joins(:vmware_facet)
-                    .includes(host_association => :host)
-                    .includes(:environment)
-                    .preload(:owner)
-                    .order(:name)
+      @newest_data = Host.authorized(:view_hosts).joins(:vmware_facet).maximum('vmware_facets.updated_at')
+      host_ids = Host.authorized(:view_hosts)
+                     .try { |query| params[:owned_only] ? query.owned_by_current_user_or_group_with_current_user : query }
+                     .pluck(:id)
+
+      @data = HostStatus.wreckingball_statuses.map do |status|
+        counter = status.where(host_id: host_ids)
+                        .select(:status)
+                        .group(:status)
+                        .count
+                        .transform_keys { |key| status.to_global(key) }
+
         {
           name: status.status_name,
-          hosts: hosts,
           description: status.description,
-          host_association: host_association,
-          supports_remediate: status.supports_remediate?
+          host_association: status.host_association,
+          supports_remediate: status.supports_remediate?,
+          counter: {
+            ok: counter[HostStatus::Global::OK] || 0,
+            warning: counter[HostStatus::Global::WARN] || 0,
+            critical: counter[HostStatus::Global::ERROR] || 0
+          }
         }
       end
     end
 
+    def status_managed_hosts_dashboard
+      vmware_compute_resources = Foreman::Model::Vmware.unscoped.all
+
+      @errors = {}
+
+      # NOTE The call to ComputeResource#vms may slow things down
+      vms_by_compute_resource_id = vmware_compute_resources.each_with_object({}) do |cr, memo|
+        memo[cr.id] = cr.vms.all
+      rescue StandardError => e
+        @errors[cr.name] = e.message
+        Foreman::Logging.exception("Failed to load VMs from compute resource #{cr.name}", e)
+      end
+
+      # Get all VM UUIDs found in any of the compute resources
+      all_vm_uuids = vms_by_compute_resource_id.values.flatten.group_by(&:id).keys
+
+      # Map all VM UUIDs to all compute resources that have access to this VM
+      @vm_compute_resource_mapping = all_vm_uuids.each_with_object({}) do |uuid, obj|
+        cr_ids = vms_by_compute_resource_id.select { |_cr_id, vms| vms.find { |vm| vm.id == uuid } }.keys
+        obj[uuid] = vmware_compute_resources.select { |cr| cr_ids.include?(cr.id) }
+      end
+
+      @missing_hosts = []
+      @wrong_hosts = []
+      @more_than_one_hosts = []
+
+      Host::Managed.authorized(:view_hosts, Host)
+                   .includes(:compute_resource)
+                   .where(compute_resource: vmware_compute_resources)
+                   .try { |query| params[:owned_only] ? query.owned_by_current_user_or_group_with_current_user : query }
+                   .each do |host|
+
+        compute_resources = @vm_compute_resource_mapping[host.uuid]
+
+        if compute_resources.empty?
+          # VM is not found on any compute resource, vSphere does not have the vm uuid
+          @missing_hosts << host
+        elsif compute_resources.count > 1
+          # The vm uuid is found on more than one compute resource
+          @more_than_one_hosts << host
+        elsif host.compute_resource_id != compute_resources.first.id
+          # The host is associated to a wrong compute resource
+          @wrong_hosts << host
+        end
+      end
+
+      @compute_resource_authorizer = Authorizer.new(User.current, collection: vmware_compute_resources)
+      @host_authorizer = Authorizer.new(User.current)
+    end
+
+    # ajax method
+    def status_hosts
+      @status = HostStatus.find_wreckingball_status_by_host_association(params.fetch(:status))
+
+      all_hosts = Host.authorized(:view_hosts, Host)
+                      .joins(@status.host_association)
+                      .try { |query| params[:owned_only] ? query.owned_by_current_user_or_group_with_current_user : query }
+                      .includes(@status.host_association, :vmware_facet, :environment)
+                      .where.not('host_status.status': @status.global_ok_list)
+                      .preload(:owner)
+                      .order(:name)
+
+      @count = all_hosts.size
+      @hosts = all_hosts.paginate(page: params.fetch(:page, 1), per_page: params.fetch(:per_page, 100))
+
+      respond_to do |format|
+        format.json do
+          Rabl::Renderer.json(@hosts, 'foreman_wreckingball/hosts/status_hosts',
+                              view_path: "#{ForemanWreckingball::Engine.root}/app/views",
+                              scope: self)
+        end
+      end
+    end
+
     def refresh_status_dashboard
-      flash[:success] = _('Refresh Compute Resource data task was successfully scheduled.')
-      task = User.as_anonymous_admin do
-        ::ForemanTasks.async_task(::Actions::ForemanWreckingball::Vmware::ScheduleVmwareSync)
+      if ForemanTasks::Task.active.where(label: ::Actions::ForemanWreckingball::Vmware::ScheduleVmwareSync.to_s).empty?
+        flash[:success] = _('Refresh Compute Resource data task was successfully scheduled.')
+        task = User.as_anonymous_admin do
+          ::ForemanTasks.async_task(::Actions::ForemanWreckingball::Vmware::ScheduleVmwareSync)
+        end
+        redirect_to(foreman_tasks_task_path(task.id))
+      else
+        flash[:warning] = _('Refresh Compute Resource data task is already running. Please wait for the running task to finish.')
+        redirect_to status_dashboard_hosts_path
       end
-      redirect_to(foreman_tasks_task_path(task.id))
     end
 
     def schedule_remediate
@@ -49,20 +129,21 @@ module ForemanWreckingball
     end
 
     def submit_remediate
-      raise Foreman::Exception, 'VMware Status can not be remediated.' unless @status.class.respond_to?(:supports_remediate?) && @status.class.supports_remediate?
-      task = User.as_anonymous_admin do
-        triggering = ::ForemanTasks::Triggering.new_from_params(triggering_params)
-        if triggering.future?
-          triggering.parse_start_at!
-          triggering.parse_start_before!
-        else
-          triggering.start_at ||= Time.zone.now
-        end
+      return not_found unless @statuses.any?
 
-        triggering.trigger(@status.class.remediate_action, @host)
+      triggering = ::ForemanTasks::Triggering.new_from_params(triggering_params)
+      if triggering.future?
+        triggering.parse_start_at!
+        triggering.parse_start_before!
+      else
+        triggering.start_at ||= Time.zone.now
       end
-      flash[:success] = _('Remediate VM task for %s was successfully scheduled.') % @host
-      redirect_to(foreman_tasks_task_path(task.id))
+
+      task = User.as_anonymous_admin do
+        triggering.trigger(::Actions::ForemanWreckingball::BulkRemediate, @statuses)
+      end
+
+      redirect_to foreman_tasks_task_path(task.id)
     end
 
     private
@@ -73,13 +154,32 @@ module ForemanWreckingball
       end
     end
 
-    def find_status
-      @status = HostStatus::Status.find_by!(:id => params[:status_id], :host_id => @host.id)
+    def statuses_params
+      @statuses_params ||= params.permit(:host_association, :owned_only, status_ids: [])
+    end
+
+    def find_statuses
+      @statuses = begin
+        host_association = statuses_params[:host_association]
+        status_class = HostStatus.find_wreckingball_status_by_host_association(host_association)
+        if status_class
+          Host.authorized(:remediate_vmware_status_hosts, Host)
+              .joins(status_class.host_association)
+              .includes(status_class.host_association)
+              .try { |query| statuses_params[:owned_only] ? query.owned_by_current_user_or_group_with_current_user : query }
+              .where.not('host_status.status': status_class.global_ok_list)
+              .map { |host| host.send(status_class.host_association) }
+        else
+          HostStatus::Status.includes(:host).where(id: statuses_params[:status_ids]).select do |status|
+            User.current.can?(:remediate_vmware_status_hosts, status.host)
+          end
+        end
+      end
     end
 
     def action_permission
       case params[:action]
-      when 'status_dashboard'
+      when 'status_dashboard', 'status_hosts', 'status_managed_hosts_dashboard'
         'view'
       when 'refresh_status_dashboard'
         'refresh_vmware_status'