foreman_discovery 4.0.0 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa7dff0a0f4756c41176a4e6b6be41f2815375cc
-  data.tar.gz: 7f83b17405564440f5939d66e15527363d07ad27
+  metadata.gz: 4ec0d128aaf7c37440c990fce555943c73bed976
+  data.tar.gz: e9b3caa61e5e0b380b14e294927a2d06c097b383
 SHA512:
-  metadata.gz: a588c3c7c19787aa5fa1cb36557e786889f294c0005bd4f1cb12dd614be77b88b2a8dbf3f46483ecf5129ad4cabc8f2a9a8cfd025eda077c9f160e0dc10debd0
-  data.tar.gz: 0e0e298f9a57c4a310e474f7dd3c6dd38b226d407a55a4a02a8e5c687b06c7149fd5c65da5cd951a61aa01e79833b7dd06539ad522a7e15f3d010aa268e1349d
+  metadata.gz: cf30e4317aab32579aca2cfa16e788917c7fee2300f717a50ca0c5915936431e4e0d3f852f3bde6423bfd4b6fe2761eb48958a1317ab2f14d84e7d97daf51336
+  data.tar.gz: 8929a780f304b8d9f56df0e10d076593271d0c593fc0d575fd4ccb7f384d5594565ed6fcea2a914f7362c73f884b1dcdb03bf481444fabc883b9c985443ae892

data/app/controllers/api/v2/discovered_hosts_controller.rb

@@ -121,8 +121,13 @@ module Api
       def auto_provision
         Host.transaction do
           if rule = find_discovery_rule(@discovered_host)
-            msg = _("Host %{host} was provisioned with rule %{rule}") % {:host => @discovered_host.name, :rule => rule.name}
-            process_response perform_auto_provision(@discovered_host, rule), msg
+            if perform_auto_provision(@discovered_host, rule)
+              msg = _("Host %{host} was provisioned with rule %{rule}") % {:host => @discovered_host.name, :rule => rule.name}
+              render :json => {:message => msg}
+            else
+              msg = _("Unable to provision %{host}: %{errors}") % {:host => @discovered_host.name, :errors => @discovered_host.errors.full_messages.join(' ')}
+              render :json => {:message => msg}, :status => :unprocessable_entity
+            end
           else
             render_error :custom_error, :status => :not_found,
                          :locals => {
@@ -145,6 +150,7 @@ module Api
           result = false
         end
 
+        total_count = 0
         Host.transaction do
           overall_errors = ""
           Host::Discovered.all.each do |discovered_host|
@@ -154,6 +160,8 @@ module Api
                 errors = discovered_host.errors.full_messages.join(' ')
                 logger.warn "Failed to auto provision host %s: %s" % [discovered_host.name, errors]
                 overall_errors << "#{discovered_host.name}: #{errors} "
+              else
+                total_count += 1
               end
             else
               logger.warn "No rule found for host %s" % discovered_host.name
@@ -161,7 +169,8 @@ module Api
           end
 
           if result
-            process_success _("Discovered hosts are provisioning now")
+            msg = _("%s discovered hosts were provisioned") % total_count
+            render :json => {:message => msg}
           else
             render_error :custom_error,
               :status => :unprocessable_entity,

data/app/models/host/discovered.rb

@@ -1,5 +1,3 @@
-require 'foreman_discovery/proxy_operations'
-
 class Host::Discovered < ::Host::Base
   include ScopedSearchExtensions
 
@@ -125,39 +123,44 @@ class Host::Discovered < ::Host::Base
     read_attribute(:root_pass).blank? ? (hostgroup.try(:root_pass) || Setting[:root_pass]) : read_attribute(:root_pass)
   end
 
+  def proxied?
+    subnet.present? && subnet.discovery.present?
+  end
+
   def proxy_url
-    if subnet.present? && subnet.discovery.present?
-      { :url => subnet.discovery.url + "/discovery/#{self.ip}", :type => 'proxy'}
-    else
-      { :url => "http://#{self.ip}:8443", :type => 'foreman' }
-    end
+    proxied? ? subnet.discovery.url + "/discovery/#{self.ip}" : "https://#{self.ip}:8443"
   end
 
   def refresh_facts
-    # TODO: Can we rely on self.ip? The lease might expire/change....
-    begin
-      logger.debug "retrieving facts from proxy from url: #{proxy_url[:url]}"
-      facts = ForemanDiscovery::ProxyOperations.new(:url => proxy_url[:url], :operation => 'facts').parse_get_operation
-    rescue Exception => e
-      raise _("Could not get facts from proxy %{url}: %{error}") % {:url => proxy_url[:url], :error => e}
-    end
-
-    return self.class.import_host_and_facts facts
+    # TODO implement new-style service, get rid of old client (legacy_api? cannot be used!)
+    facts = ForemanDiscovery::ProxyOperations.new(:url => proxy_url, :operation => 'facts').parse_get_operation
+    self.class.import_host_and_facts facts
+  rescue Exception => e
+    raise _("Could not get facts from proxy %{url}: %{error}") % {:url => proxy_url, :error => e}
   end
 
-  def reboot
-    logger.info "ForemanDiscovery: Rebooting #{name}"
-    proxy_url = self.proxy_url
-
-    if proxy_url[:type] == 'proxy'
-      ForemanDiscovery::ProxyOperations.new(:url => proxy_url[:url], :operation => 'reboot').
-        parse_put_operation.try(:fetch, 'result')
+  def reboot legacy_api = ForemanDiscovery::HostConverter.legacy_host(self)
+    if legacy_api
+      if proxied?
+        resource = ::ForemanDiscovery::NodeAPI::Power.legacy_proxied_service(:url => proxy_url)
+      else
+        resource = ::ForemanDiscovery::NodeAPI::Power.legacy_direct_service(:url => proxy_url)
+      end
     else
-      ::ProxyAPI::BMC.new(:url => "http://#{self.ip}:8443").power :action => "cycle"
+      resource = ::ForemanDiscovery::NodeAPI::Power.service(:url => proxy_url)
     end
+    resource.reboot
   rescue => e
     ::Foreman::Logging.exception("Unable to reboot #{name}", e)
-    raise ::Foreman::WrappedException.new(e, N_("Unable to reboot %{name}: %{msg}"), :name => name, :msg => e.to_s)
+    raise ::Foreman::WrappedException.new(e, N_("Unable to reboot %{name} via %{url}: %{msg}"), :name => name, :url => proxy_url, :msg => e.to_s)
+  end
+
+  def kexec json
+    resource = ::ForemanDiscovery::NodeAPI::Power.service(:url => proxy_url)
+    resource.kexec json
+  rescue => e
+    ::Foreman::Logging.exception("Unable to perform kexec on #{name}", e)
+    raise ::Foreman::WrappedException.new(e, N_("Unable to perform kexec on %{name} via %{url}: %{msg}"), :name => name, :url => proxy_url, :msg => e.to_s)
   end
 
   def self.model_name

data/app/models/host/managed_extensions.rb

@@ -7,6 +7,9 @@ module Host::ManagedExtensions
     after_save :delete_discovery_attribute_set
 
     belongs_to :discovery_rule
+
+    # extra flag for post_queue callbacks which has no access to facts
+    attr_accessor :legacy_api
   end
 
   def queue_reboot
@@ -14,12 +17,15 @@ module Host::ManagedExtensions
     return if new_record? # Discovered Hosts already exist, and new_records will break `find`
     return unless type_changed? and ::Host::Base.find(self.id).type == "Host::Discovered"
     # reboot task must be high priority and there is no compensation action apparently
-    post_queue.create(:name => _("Rebooting %s") % self, :priority => 10000,
-                      :action => [self, :setReboot])
+    if facts['discovery_kexec'] && provisioning_template(:kind => 'kexec')
+      post_queue.create(:name => _("Reloading kernel on %s") % self, :priority => 10000, :action => [self, :setKexec])
+    else
+      post_queue.create(:name => _("Rebooting %s") % self, :priority => 10000, :action => [self, :setReboot])
+    end
   end
 
   def setReboot
-    old.becomes(Host::Discovered).reboot
+    old.becomes(Host::Discovered).reboot legacy_api
     # It is too late to report error in the post_queue, we catch them and
     # continue. If flash is implemented for new hosts (http://projects.theforeman.org/issues/10559)
     # we can report the error to the user perhaps.
@@ -28,6 +34,21 @@ module Host::ManagedExtensions
     true
   end
 
+  def boot_url pxe_file
+    operatingsystem.medium_vars_to_uri("#{medium.path}/#{operatingsystem.url_for_boot(pxe_file)}", architecture.name, operatingsystem).to_s
+  end
+
+  def setKexec
+    template = provisioning_template(:kind => 'kexec')
+    @kernel = boot_url(:kernel)
+    @initrd = boot_url(:initrd)
+    json = unattended_render(template)
+    old.becomes(Host::Discovered).kexec json
+    true
+  rescue ::Foreman::Exception
+    true
+  end
+
   def delete_discovery_attribute_set
     return if new_record?
     DiscoveryAttributeSet.destroy_all(:host_id => self.id) if type_changed?

data/app/services/foreman_discovery/host_converter.rb

@@ -14,9 +14,23 @@ class ForemanDiscovery::HostConverter
       host.managed = set_managed
       host.primary_interface.managed = set_managed
     end
-    # set build only and only on final save (otherwise interfaces are not being identified)
-    host.build = set_build if set_build
+    # set build only and only on final save (facts are deleted)
+    if set_build
+      # set legacy_api flag for post_queue actions
+      host.legacy_api = self.legacy_host(host)
+      # do not delete all facts (keep discovery ones)
+      host.define_singleton_method(:clearFacts) do
+        keep_ids = FactValue.where("host_id = #{host.id}").joins(:fact_name).where("fact_names.name like 'discovery_%'").pluck(:id)
+        FactValue.where("host_id = #{host.id} and id not in (?)", keep_ids).delete_all
+      end
+      # set build flag (also deletes facts)
+      host.build = set_build
+    end
     host
   end
 
+  def self.legacy_host(host)
+    Gem::Version.new(host.facts['discovery_version'] || '1.0.0') < Gem::Version.new('3.0.0')
+  end
+
 end

data/app/services/foreman_discovery/node_api/node_resource.rb

@@ -0,0 +1,117 @@
+module ForemanDiscovery::NodeAPI
+  class NodeResource
+    def initialize(args)
+      raise ArgumentError, "Options must be hash" unless args.is_a?(Hash)
+      raise ArgumentError, "Option 'url' must be provided" unless args[:url]
+      @args = args
+      @connect_params = {
+        :headers => { :accept => :json },
+      }
+
+      if url.match(/^https/i) && Rails.env != "test"
+        if is_proxy?
+          logger.debug "Connecting to proxy, setting up SSL client cert"
+          cert         = Setting[:ssl_certificate]
+          ca_cert      = Setting[:ssl_ca_file]
+          hostprivkey  = Setting[:ssl_priv_key]
+
+          @connect_params.merge!(
+            :ssl_client_cert  =>  OpenSSL::X509::Certificate.new(File.read(cert)),
+            :ssl_client_key   =>  OpenSSL::PKey::RSA.new(File.read(hostprivkey)),
+            :ssl_ca_file      =>  ca_cert,
+            :verify_ssl       =>  OpenSSL::SSL::VERIFY_PEER
+          )
+        else
+          logger.debug "Connecting without proxy, not using SSL client cert"
+          @connect_params.merge!(
+            :verify_ssl       =>  OpenSSL::SSL::VERIFY_NONE
+          )
+        end
+      end
+    end
+
+    def url
+      @args[:url]
+    end
+
+    def scheme
+      URI.parse(url).scheme
+    rescue Exception => e
+      raise ArgumentError, "Option 'url' must be valid URI: #{e}"
+    end
+
+    def port
+      URI.parse(url).port
+    rescue Exception => e
+      raise ArgumentError, "Option 'url' must be valid URI: #{e}"
+    end
+
+    def root_path
+      URI.parse(url).path
+    rescue Exception => e
+      raise ArgumentError, "Option 'url' must be valid URI: #{e}"
+    end
+
+    def is_proxy?
+      root_path.starts_with?('/discovery')
+    end
+
+    protected
+
+    attr_reader :connect_params
+
+    def resource
+      @resource ||= RestClient::Resource.new(url, connect_params)
+    end
+
+    def logger; Rails.logger; end
+
+    private
+
+    def parse(response)
+      if response and response.code >= 200 and response.code < 300
+        return response.body.present? ? JSON.parse(response.body) : {}
+      else
+        raise ::Foreman::Exception.new(N_("Image API returned HTTP/%{code} with '%{body}"), :body => response.body, :code => response.code)
+      end
+    rescue => e
+      raise ::Foreman::WrappedException.new(e, N_("Image API processing error: %{msg} (HTTP/%{code}, body: %{body})"), :msg => e.to_s, :body => response.try(:body), :code => response.try(:code))
+    end
+
+    def get(payload = {}, path = nil)
+      logger.debug("Image API GET #{url} (path=#{path}, payload=#{payload})")
+      if path
+        resource[URI.escape(path)].get payload
+      else
+        resource.get payload
+      end
+    end
+
+    def post(payload, path = nil)
+      logger.debug("Image API POST #{url} (path=#{path}, payload=#{payload})")
+      if path
+        resource[path].post payload
+      else
+        resource.post payload
+      end
+    end
+
+    def put(payload, path = nil)
+      logger.debug("Image API PUT #{url} (path=#{path}, payload=#{payload})")
+      if path
+        resource[path].put payload
+      else
+        resource.put payload
+      end
+    end
+
+    def delete(path)
+      logger.debug("Image API DELETE #{url} (path=#{path})")
+      if path
+        resource[path].delete
+      else
+        resource.delete
+      end
+    end
+  end
+end

data/app/services/foreman_discovery/node_api/power.rb

@@ -0,0 +1,57 @@
+module ForemanDiscovery::NodeAPI
+  class Power
+    class << self
+      def service(data)
+        PowerService.new(data)
+      end
+
+      def legacy_direct_service(data)
+        PowerLegacyDirectService.new(data)
+      end
+
+      def legacy_proxied_service(data)
+        PowerLegacyProxiedService.new(data)
+      end
+    end
+  end
+
+  class PowerService < NodeResource
+    def url
+      @args[:url] + "/power"
+    end
+
+    def reboot
+      put({}, "/reboot")
+    end
+
+    def kexec(json)
+      put(json, "/kexec")
+    end
+
+  end
+
+  # legacy /reboot call direct
+  class PowerLegacyDirectService < NodeResource
+    def initialize(args)
+      super args
+      raise ArgumentError, "Legacy direct service only supports http scheme" if scheme != 'http'
+      raise ArgumentError, "Legacy direct service only supports port 8443" if port != 8443
+      Foreman::Deprecation.deprecation_warning("1.11", "Discovery legacy API will be removed, use the new Power API")
+    end
+
+    def reboot
+      ::ProxyAPI::BMC.new(:url => url).power :action => "cycle"
+    end
+  end
+
+  # legacy /reboot call via proxy
+  class PowerLegacyProxiedService < NodeResource
+    def initialize(args)
+      super args.merge(:proxy => true)
+    end
+
+    def reboot
+      put({}, "/reboot")
+    end
+  end
+end

data/app/views/foreman_discovery/redhat_kexec.erb

@@ -0,0 +1,44 @@
+<%#
+kind: kexec
+name: Red Hat kexec
+oses:
+- CentOS 4
+- CentOS 5
+- CentOS 6
+- CentOS 7
+- Fedora 19
+- Fedora 20
+- Fedora 21
+- Fedora 22
+- RedHat 4
+- RedHat 5
+- RedHat 6
+- RedHat 7
+-%>
+<%#
+This template is used to pass command line options to kexec when reloading
+kernel on a discovered host instead of rebooting. This is useful in PXE-less
+environments. The template must generate JSON format with three items:
+"kernel", "initram" and "append". Read kexec(8) man page for more
+information about semantics.
+-%>
+<%
+  mac = @host.facts['discovery_bootif']
+  bootif = '00-' + mac.gsub(':', '-')
+  ip_cidr = @host.facts['discovery_ip_cidr']
+  ip = @host.facts['discovery_ip']
+  mask = @host.facts['discovery_netmask']
+  gw = @host.facts['discovery_gateway']
+  dns = @host.facts['discovery_dns']
+  append = @host.facts['append']
+-%>
+{
+  "kernel": "<%= @kernel %>",
+  "initram": "<%= @initrd %>",
+<% if (@host.operatingsystem.name == 'Fedora' and @host.operatingsystem.major.to_i > 16) or
+    (@host.operatingsystem.name != 'Fedora' and @host.operatingsystem.major.to_i >= 7) -%>
+  "append": "ks=<%= foreman_url('provision') + "&static=yes" %> inst.ks.sendmac <%= "ip=#{ip}::#{gw}:#{mask}:::none nameserver=#{dns} ksdevice=bootif BOOTIF=#{bootif} #{append}" %>"
+<% else -%>
+  "append": "ks=<%= foreman_url('provision') + "&static=yes" %> kssendmac <%= "ip=#{ip} netmask=#{mask} gateway=#{gw} dns=#{dns} ksdevice=#{mac} BOOTIF=#{bootif} #{append}" %>"
+<% end -%>
+}

data/db/seeds.d/50_discovery_templates.rb

@@ -0,0 +1,18 @@
+kind = TemplateKind.find_or_create_by_name('kexec')
+
+ProvisioningTemplate.without_auditing do
+  content = File.read(File.join(ForemanDiscovery::Engine.root, 'app', 'views', 'foreman_discovery', 'redhat_kexec.erb'))
+  tmpl = ProvisioningTemplate.find_or_create_by_name(
+    :name => 'Discovery Red Hat kexec',
+    :template_kind_id => kind.id,
+    :snippet => false,
+    :template => content
+  )
+  tmpl.attributes = {
+    :template => content,
+    :default  => true,
+    :vendor   => "Foreman Discovery",
+    :locked   => false
+  }
+  tmpl.save!(:validate => false) if tmpl.changes.present?
+end