foreman_wreckingball 0.1.0

data/Rakefile

@@ -0,0 +1,47 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ForemanWreckingball'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path('../test/dummy/Rakefile', __FILE__)
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test
+
+begin
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+rescue => _
+  puts 'Rubocop not loaded.'
+end
+
+task :default do
+  Rake::Task['rubocop'].execute
+end

data/app/controllers/foreman_wreckingball/hosts_controller.rb

@@ -0,0 +1,60 @@
+module ForemanWreckingball
+  class HostsController < ::HostsController
+    before_action :find_resource, :only => [:remediate]
+    before_action :find_status, :only => [:remediate]
+
+    def status_dashboard
+      statuses = [
+        ToolsStatus,
+        OperatingsystemStatus,
+        CpuHotAddStatus
+      ]
+
+      @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)
+        {
+          name: status.status_name,
+          hosts: hosts,
+          description: status.description,
+          host_association: host_association,
+          supports_remediate: status.supports_remediate?
+        }
+      end
+    end
+
+    def refresh_status_dashboard
+      flash[:success] = _('Refresh Compute Resource data task was successfully scheduled.')
+      task = ::ForemanTasks.async_task(::Actions::ForemanWreckingball::Vmware::ScheduleVmwareSync)
+      redirect_to(foreman_tasks_task_path(task.id))
+    end
+
+    def remediate
+      raise Foreman::Exception.new('VMware Status can not be remediated.') unless @status.class.respond_to?(:supports_remediate?) && @status.class.supports_remediate?
+      flash[:success] = _('Remediate VM task for %s was successfully scheduled.') % @host
+      task = ::ForemanTasks.async_task(::Actions::ForemanWreckingball::Host::RemediateVmwareOperatingsystem, @host)
+      redirect_to(foreman_tasks_task_path(task.id))
+    end
+
+    private
+
+    def find_status
+      @status = HostStatus::Status.find_by!(:id => params[:status_id], :host_id => @host.id)
+    end
+
+    def action_permission
+      case params[:action]
+      when 'status_dashboard'
+        'view'
+      when 'refresh_status_dashboard'
+        'refresh_vmware_status'
+      when 'remediate'
+        'remediate_vmware_status'
+      else
+        super
+      end
+    end
+  end
+end

data/app/helpers/concerns/foreman_wreckingball/hosts_helper_extensions.rb

@@ -0,0 +1,26 @@
+module ForemanWreckingball
+  module HostsHelperExtensions
+    extend ActiveSupport::Concern
+
+    def classes_for_vmware_status_row(counter)
+      return 'pficon-error-circle-o list-view-pf-icon-danger' if (counter[:critical] || 0) > 0
+      return 'pficon-warning-triangle-o list-view-pf-icon-warning' if (counter[:warning] || 0) > 0
+      'pficon-ok list-view-pf-icon-success'
+    end
+
+    def vmware_status_counter(hosts, status_object)
+      count = hosts.map do |host|
+        host.public_send(status_object).to_global
+      end.group_by do |status|
+        status
+      end.each_with_object({}) do |(status, items), hash|
+        hash[status]=items.size
+      end
+      {
+        :ok => count[HostStatus::Global::OK] || 0,
+        :warning => count[HostStatus::Global::WARN] || 0,
+        :critical => count[HostStatus::Global::ERROR] || 0
+      }
+    end
+  end
+end

data/app/jobs/update_hosts_vmware_facets.rb

@@ -0,0 +1,8 @@
+class UpdateHostsVmwareFacets < ActiveJob::Base
+  after_perform do
+    self.class.set(:wait => 12.hours).perform_later
+  end
+
+  def perform
+  end
+end

data/app/lib/actions/foreman_wreckingball/host/refresh_vmware_facet.rb

@@ -0,0 +1,32 @@
+module Actions
+  module ForemanWreckingball
+    module Host
+      class RefreshVmwareFacet < Actions::EntryAction
+        def plan(host)
+          action_subject(host)
+          plan_self
+        end
+
+        def run
+          User.as_anonymous_admin do
+            host = ::Host.find(input[:host][:id])
+            state = host.refresh_vmware_facet!
+            output[:state] = state
+          end
+        end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
+
+        def humanized_name
+          _('Refresh VMware data')
+        end
+
+        def humanized_input
+          input[:host] && input[:host][:name]
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_wreckingball/host/remediate_vmware_operatingsystem.rb

@@ -0,0 +1,82 @@
+module Actions
+  module ForemanWreckingball
+    module Host
+      class RemediateVmwareOperatingsystem < Actions::EntryAction
+        def plan(host)
+          action_subject(host)
+          plan_self
+        end
+
+        def run
+          User.as_anonymous_admin do
+            host = ::Host.find(input[:host][:id])
+
+            fail _('Foreman does not know the Architecture of this host.') unless host.architecture
+            fail _('Foreman does not know the Operatingsystem of this host.') unless host.operatingsystem
+
+            initially_powered_on = host.power.ready?
+            output[:initially_powered_on] = initially_powered_on
+
+            vm = host.compute_object
+
+            if initially_powered_on
+              vm.stop
+              vm.wait_for { power_state == 'poweredOff' }
+            end
+
+            fail _('Could not shut down VM.') if vm.ready?
+
+            current_os_id = host.vmware_facet.guest_id
+            current_os = VsphereOsIdentifiers.lookup(current_os_id)
+
+            selectors = {
+              :architecture => host.architecture.name,
+              :osfamily => host.operatingsystem.family,
+              :name => host.operatingsystem.name,
+              :major => host.operatingsystem.major.to_i
+            }
+
+            desired_os = VsphereOsIdentifiers.find_by(selectors)
+            desired_os ||= VsphereOsIdentifiers.find_by(selectors.except(:major))
+            desired_os ||= VsphereOsIdentifiers.find_by(selectors.except(:major, :name))
+
+            fail _('Could not auto detect desired operatingsystem.') unless desired_os
+
+            fail _('VMs current and desired OS (%s) already match. No update necessary.') % current_os.description if current_os == desired_os
+
+            output[:old_operatingsystem] = current_os.description
+            output[:old_operatingsystem_id] = current_os.id
+            output[:new_operatingsytem] = desired_os.description
+            output[:new_operatingsytem_id] = desired_os.id
+
+            vm.vm_reconfig_hardware({'guestId' => desired_os.id})
+
+            if initially_powered_on
+              vm.start
+            end
+
+            state = host.refresh_vmware_facet!
+            output[:state] = state
+          end
+        end
+
+        def humanized_name
+          _('Correct VM Operatingsystem')
+        end
+
+        def humanized_input
+          input[:host] && input[:host][:name]
+        end
+
+        def append_error(message)
+          output[:errors] ||= []
+          output[:errors] << message
+        end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_wreckingball/vmware/schedule_vmware_sync.rb

@@ -0,0 +1,24 @@
+module Actions
+  module ForemanWreckingball
+    module Vmware
+      class ScheduleVmwareSync < Actions::EntryAction
+        def plan
+          compute_resources = ComputeResource.where(:type => 'Foreman::Model::Vmware')
+          sequence do
+            compute_resources.each do |compute_resource|
+              plan_action(::Actions::ForemanWreckingball::Vmware::SyncComputeResource, compute_resource)
+            end
+          end
+        end
+
+        def humanized_name
+          _('VMware Data Synchronization')
+        end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_wreckingball/vmware/sync_compute_resource.rb

@@ -0,0 +1,45 @@
+module Actions
+  module ForemanWreckingball
+    module Vmware
+      class SyncComputeResource < Actions::EntryAction
+        def plan(compute_resource)
+          action_subject(compute_resource)
+          plan_self
+        end
+
+        def run
+          User.as_anonymous_admin do
+            compute_resource = ComputeResource.find(input[:compute_resource][:id])
+            ::ForemanWreckingball::VmwareClusterImporter.new(
+              :compute_resource => compute_resource
+            ).import!
+
+            ::ForemanWreckingball::VmwareHypervisorImporter.new(
+              :compute_resource => compute_resource.reload
+            ).import!
+
+            compute_resource.hosts.each do |host|
+              host.refresh_vmware_facet!
+            end
+          end
+        end
+
+        def humanized_name
+          _('Refresh Compute Resource')
+        end
+
+        def resource_locks
+          :update
+        end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
+
+        def self.cleanup_after
+          '1d'
+        end
+      end
+    end
+  end
+end

data/app/lib/fog_extensions/foreman_wreckingball/vsphere/host.rb

@@ -0,0 +1,38 @@
+module FogExtensions
+  module ForemanWreckingball
+    module Vsphere
+      module Host
+        extend ActiveSupport::Concern
+
+        module Overrides
+          def vm_ids
+            attributes[:vm_ids] = attributes[:vm_ids].call if attributes[:vm_ids].is_a?(Proc)
+            attributes[:vm_ids]
+          end
+        end
+
+        included do
+          prepend Overrides
+
+          attribute :cpu_cores
+          attribute :cpu_sockets
+          attribute :cpu_threads
+          attribute :memory
+          attribute :uuid
+          attribute :model
+          attribute :vendor
+          attribute :ipaddress
+          attribute :ipaddress6
+          attribute :product_name
+          attribute :product_version
+          attribute :hostname
+          attribute :domainname
+        end
+
+        def memory_mb
+          memory / 1024 / 1024
+        end
+      end
+    end
+  end
+end

data/app/lib/fog_extensions/foreman_wreckingball/vsphere/real.rb

@@ -0,0 +1,85 @@
+module FogExtensions
+  module ForemanWreckingball
+    module Vsphere
+      module Real
+        extend ActiveSupport::Concern
+
+        module Overrides
+          def list_hosts(filters = {})
+            cluster = get_raw_cluster(filters[:cluster], filters[:datacenter])
+
+            results = property_collector_results(host_system_filter_spec(cluster))
+
+            results.map do |host|
+              hsh = map_attrs_to_hash(host, host_system_attribute_mapping)
+              hsh.merge(
+                datacenter: filters[:datacenter],
+                cluster: filters[:cluster],
+                ipaddress: (host['config.network.vnic'].first.spec.ip.ipAddress rescue nil),
+                ipaddress6: (host['config.network.vnic'].first.spec.ip.ipV6Config.ipV6Address.first.ipAddress rescue nil),
+                vm_ids: Proc.new { host['vm'].map {|vm| vm.config.instanceUuid rescue nil} }
+              )
+            end
+          end
+        end
+
+        included do
+          prepend Overrides
+        end
+
+        protected
+
+        def map_attrs_to_hash(obj, attribute_mapping)
+          attribute_mapping.each_with_object({}) do |(k, v), hsh|
+            hsh[k] = obj[v]
+          end
+        end
+
+        def property_collector_results(filter_spec)
+          property_collector = connection.serviceContent.propertyCollector
+          property_collector.RetrieveProperties(:specSet => [filter_spec])
+        end
+
+        def compute_resource_host_traversal_spec
+          RbVmomi::VIM.TraversalSpec(
+            :name => 'computeResourceHostTraversalSpec',
+            :type => 'ComputeResource',
+            :path => 'host',
+            :skip => false
+          )
+        end
+
+        def host_system_filter_spec(obj)
+          RbVmomi::VIM.PropertyFilterSpec(
+            :objectSet => [
+              :obj => obj,
+              :selectSet => [
+                compute_resource_host_traversal_spec
+              ]
+            ],
+            :propSet => [
+              { :type => 'HostSystem', :pathSet => host_system_attribute_mapping.values + ['config.network.vnic', 'vm'] }
+            ]
+          )
+        end
+
+        def host_system_attribute_mapping
+          {
+            name:            'name',
+            cpu_cores:       'hardware.cpuInfo.numCpuCores',
+            cpu_sockets:     'hardware.cpuInfo.numCpuPackages',
+            cpu_threads:     'hardware.cpuInfo.numCpuThreads',
+            memory:          'hardware.memorySize',
+            uuid:            'hardware.systemInfo.uuid',
+            model:           'hardware.systemInfo.model',
+            vendor:          'hardware.systemInfo.vendor',
+            product_name:    'summary.config.product.name',
+            product_version: 'summary.config.product.version',
+            hostname:        'config.network.dnsConfig.hostName',
+            domainname:      'config.network.dnsConfig.domainName'
+          }
+        end
+      end
+    end
+  end
+end