foreman_acd 0.2.1 → 0.3.0

data/app/controllers/foreman_acd/concerns/ansible_playbook_parameters.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ForemanAcd
+  module Concerns
+    # Parameters for AnsiblePlaybooks
+    module AnsiblePlaybookParameters
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def ansible_playbook_params_filter
+          Foreman::ParameterFilter.new(::ForemanAcd::AnsiblePlaybook).tap do |filter|
+            filter.permit(:name, :description, :scm_type, :path, :playfile)
+          end
+        end
+      end
+
+      def ansible_playbook_params
+        param_name = parameter_filter_context.api? ? 'ansible_playbook' : 'foreman_acd_ansible_playbook'
+        self.class.ansible_playbook_params_filter.filter_params(params, parameter_filter_context, param_name)
+      end
+    end
+  end
+end

data/app/controllers/foreman_acd/concerns/app_definition_parameters.rb

@@ -9,7 +9,7 @@ module ForemanAcd
       class_methods do
         def app_definition_params_filter
           Foreman::ParameterFilter.new(::ForemanAcd::AppDefinition).tap do |filter|
-            filter.permit(:name, :description, :services)
+            filter.permit(:name, :description, :acd_ansible_playbook_id, :services, :ansible_vars_all)
           end
         end
       end

data/app/controllers/foreman_acd/concerns/app_instance_parameters.rb

@@ -9,7 +9,7 @@ module ForemanAcd
       class_methods do
         def app_instance_params_filter
           Foreman::ParameterFilter.new(::ForemanAcd::AppInstance).tap do |filter|
-            filter.permit(:name, :app_definition_id, :description, :hosts)
+            filter.permit(:name, :app_definition_id, :description, :hosts, :ansible_vars_all)
           end
         end
       end

data/app/controllers/ui_acd_controller.rb

@@ -8,13 +8,17 @@ class UiAcdController < ::Api::V2::BaseController
     @app_data['app_definition'] = app_definition
   end
 
-  def fdata
-    @fdata = collect_fdata(params['id'])
+  def foreman_data
+    @foreman_data = collect_foreman_data(params['id'])
+  end
+
+  def ansible_data
+    @ansible_data = collect_ansible_data(params['id'])
   end
 
   private
 
-  def collect_fdata(hostgroup_id)
+  def collect_foreman_data(hostgroup_id)
     hg = Hostgroup.find(hostgroup_id)
     fdata = OpenStruct.new(
       :environments => Environment.all,
@@ -26,4 +30,8 @@ class UiAcdController < ::Api::V2::BaseController
     )
     fdata
   end
+
+  def collect_ansible_data(playbook_id)
+    ForemanAcd::AnsiblePlaybook.find(playbook_id).as_unified_structobj
+  end
 end

data/app/models/foreman_acd/ansible_playbook.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ForemanAcd
+  # Ansible playbook
+  class AnsiblePlaybook < ApplicationRecord
+    include Authorizable
+    extend FriendlyId
+    friendly_id :name
+
+    self.table_name = 'acd_ansible_playbooks'
+    has_many :app_definitions, :inverse_of => :ansible_playbook, :dependent => :destroy
+    validates :name, :presence => true, :uniqueness => true
+    scoped_search :on => :name
+    default_scope -> { order("acd_ansible_playbooks.name") }
+
+    def self.humanize_class_name(_name = nil)
+      _('Ansible playbook')
+    end
+
+    def self.permission_name
+      'ansible_playbooks'
+    end
+
+    def content
+      case scm_type
+      when 'directory'
+        File.read(File.join(path, playfile))
+      else
+        raise NotImplementedError.new "scm_type #{scm_type.inspect} not supported!"
+      end
+    end
+
+    def as_unified_structobj
+      groups = []
+
+      JSON.load(self.vars).each do |group_name, vars|
+        groups << OpenStruct.new(
+          :name => group_name,
+          :vars => vars.map { |k,v| OpenStruct.new(:name => k, :value => v) })
+      end
+
+      adata = OpenStruct.new(
+        :id => self.id,
+        :name => self.name,
+        :groups => JSON.load(self.vars)
+      )
+      adata
+    end
+  end
+end

data/app/models/foreman_acd/app_definition.rb

@@ -9,7 +9,9 @@ module ForemanAcd
 
     validates :name, :presence => true, :uniqueness => true
     has_many :app_instances, :inverse_of => :app_definition, :dependent => :destroy
+    belongs_to :ansible_playbook, :inverse_of => :app_definitions, :foreign_key => :acd_ansible_playbook_id
     scoped_search :on => :name
+    default_scope -> { order("app_definitions.name") }
 
     def self.humanize_class_name(_name = nil)
       _('App Definition')

data/app/models/foreman_acd/app_instance.rb

@@ -9,6 +9,7 @@ module ForemanAcd
     validates :name, :presence => true, :uniqueness => true
     belongs_to :app_definition, :inverse_of => :app_instances
     scoped_search :on => :name
+    default_scope -> { order("app_instances.name") }
 
     def self.humanize_class_name(_name = nil)
       _('App Instance')
@@ -17,5 +18,11 @@ module ForemanAcd
     def self.permission_name
       'app_instances'
     end
+
+    def foreman_hosts
+      app_hosts = JSON.parse(self.hosts)
+      host_ids = app_hosts.select{ |h| h&.key?('foreman_host_id') }.map{ |h| h['foreman_host_id'] }
+      ::Host.find(host_ids)
+    end
   end
 end

data/app/services/foreman_acd/app_configurator.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module ForemanAcd
+  # application instances configurator
+  class AppConfigurator
+
+    delegate :logger, :to => :Rails
+
+    def initialize(app_instance)
+      @app_instance = app_instance
+    end
+
+    def configure
+      job_input = {}
+      job_input['application_name'] = @app_instance.name
+      job_input['playbook_name'] = @app_instance.app_definition.ansible_playbook.name
+      job_input['playbook_path'] = File.join(@app_instance.app_definition.ansible_playbook.path,
+                                            @app_instance.app_definition.ansible_playbook.playfile)
+
+      # TODO should or do we really need it to a file?
+      #inventory_file = File.new("/tmp/acd_inventory_file", "w") # we can also use Tempfile.new() but a tempfile will be deleted soon (after transaction finished)
+      #inventory_file << inventory.to_yaml
+      #inventory_file.close
+
+      logger.info("Use inventory to configure #{@app_instance.name} with ansible playbook #{@app_instance.app_definition.ansible_playbook.name}")
+
+      begin
+        proxy_hosts = {}
+        jobs = []
+
+        hosts = @app_instance.foreman_hosts
+        proxy_selector = RemoteExecutionProxySelector.new
+        hosts.each do |h|
+          proxy = proxy_selector.determine_proxy(h, 'SSH')
+          unless proxy_hosts.has_key?(proxy.name)
+            proxy_hosts[proxy.name] = Array.new
+          end
+          proxy_hosts[proxy.name] << h.id
+        end
+
+        # TODO just for testing...
+        #proxy_hosts = { Host.first.name => [ Host.first.id] }
+
+        # we need to compose multiple jobs. for each proxy one job.
+        proxy_hosts.each do |proxy_name, host_names|
+          # create the inventory file
+          inventory = ForemanAcd::InventoryCreator.new(@app_instance, host_names).create_inventory
+          job_input['inventory'] = YAML.dump(inventory)
+
+          # Unfortunately, we can not use "JobInvocationComposer.for_feature" method
+          # because then its not possible to the set effective_user
+          job = JobTemplate.find(RemoteExecutionFeature.feature('run_acd_ansible_playbook').job_template_id)
+          params = {
+            :job_category => job.job_category,
+            :job_template_id => job.id,
+            :targeting_type => 'static_query',
+            :search_query => "name = #{proxy_name}",
+            :effective_user => 'foreman-proxy',
+            :inputs => job_input.to_hash
+          }
+          composer = JobInvocationComposer.from_api_params(params)
+          jobs << composer
+        end
+      rescue StandardError => e
+        logger.error("Failed to configure hosts: #{e.class}: #{e.message}\n#{e.backtrace.join($INPUT_RECORD_SEPARATOR)}")
+      end
+      jobs
+    end
+  end
+end

data/app/services/foreman_acd/app_deployer.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module ForemanAcd
+  # application instances deployer
+  class AppDeployer
+
+    delegate :logger, :to => :Rails
+    attr_reader :deploy_hosts
+
+    def initialize(app_instance)
+      @app_instance = app_instance
+      @deploy_hosts = []
+    end
+
+    def deploy
+      services = JSON.parse(@app_instance.app_definition.services)
+      app_hosts = JSON.parse(@app_instance.hosts)
+
+      app_hosts.each do |host_data|
+        begin
+          service_data = services.select { |k| k['id'] == host_data['service'].to_i }.first
+          host_params = set_host_params(host_data, service_data)
+
+          host = nil
+          if host_data.has_key?('foreman_host_id')
+            logger.debug("Try to find host with id #{host_data['foreman_host_id']}")
+            begin
+              host = Host.find(host_data['foreman_host_id'])
+            rescue ActiveRecord::RecordNotFound
+              logger.info("Host with id #{host_data['foreman_host_id']} couldn\'t be found, create a new one!")
+              host = nil
+            end
+          end
+
+          if host.nil?
+            params = host_attributes(host_params)
+            logger.info("Host creation parameters for #{host_data['hostname']}:\n#{params}\n")
+            host = Host.new(params)
+          else
+            logger.info("Update parameters and re-deploy host #{host_data['hostname']}")
+            host.attributes = host_attributes(host_params, host)
+            host.setBuild
+            host.power.reset
+          end
+
+          # REMOVE ME (but very nice for testing)
+          #host.mac = "00:11:22:33:44:55"
+
+          apply_compute_profile(host)
+          host.suggest_default_pxe_loader
+          host.save
+
+          # save the foreman host id
+          host_data['foreman_host_id'] = host.id
+
+          @deploy_hosts.push({ id: host.id, name: host_data['hostname'], hostname: host.hostname, hostUrl: host_path(h), progress_report_id: host.progress_report_id})
+        rescue StandardError => e
+          logger.error("Failed to initiate host creation: #{e.class}: #{e.message}\n#{e.backtrace.join($INPUT_RECORD_SEPARATOR)}")
+        end
+      end
+
+      return app_hosts
+    end
+
+    private
+
+    # Copied from foreman/app/controllers/api/v2/hosts_controller.rb
+    def apply_compute_profile(host)
+      host.apply_compute_profile(InterfaceMerge.new(:merge_compute_attributes => true))
+      host.apply_compute_profile(ComputeAttributeMerge.new)
+    end
+
+    # Copied from foreman/app/controllers/api/v2/hosts_controller.rb
+    def host_attributes(params, host = nil)
+      return {} if params.nil?
+
+      params = params.deep_clone
+      if params[:interfaces_attributes]
+        # handle both hash and array styles of nested attributes
+        params[:interfaces_attributes] = params[:interfaces_attributes].values if params[:interfaces_attributes].is_a?(Hash) || params[:interfaces_attributes].is_a?(ActionController::Parameters)
+        # map interface types
+        params[:interfaces_attributes] = params[:interfaces_attributes].map do |nic_attr|
+          interface_attributes(nic_attr, :allow_nil_type => host.nil?)
+        end
+      end
+      params = host.apply_inherited_attributes(params) if host
+      params
+    end
+
+    # Copied from foreman/app/controllers/api/v2/hosts_controller.rb
+    def interface_attributes(params, allow_nil_type: false)
+      params[:type] = InterfaceTypeMapper.map(params[:type]) if params.key?(:type) || allow_nil_type
+      params
+    end
+
+    def hardcoded_params
+      result = {}
+      result['managed'] = true
+      result['enabled'] = true
+      result['build'] = true
+      result['compute_attributes'] = { 'start' => '1' }
+      result['host_parameters_attributes'] = []
+      result
+    end
+
+    def set_host_params(host_data, service_data)
+      result = hardcoded_params
+      result['name'] = host_data['hostname']
+      result['hostgroup_id'] = service_data['hostgroup']
+
+      host_data['foremanParameters'].each do |param|
+        case param['type']
+
+        when 'computeprofile'
+          result['compute_profile_id'] = param['value']
+
+        when 'domain'
+          result['domain_id'] = param['value']
+
+        when 'hostparam'
+          result['host_parameters_attributes'].push(:name => param['name'], :value => param['value'])
+
+        when 'ip'
+          result['ip'] = param['value']
+
+        when 'lifecycleenv'
+          result['content_facet_attributes'] = { 'lifecycle_environment_id' => param['value'] }
+
+        when 'ptable'
+          result['ptable_id'] = param['value']
+
+        when 'puppetenv'
+          result['environment_id'] = param['value']
+
+        when 'password'
+          result['root_pass'] = param['value']
+
+        end
+      end
+      result
+    end
+  end
+end

data/app/services/foreman_acd/inventory_creator.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module ForemanAcd
+  # inventory creator for application instances
+  class InventoryCreator
+
+    delegate :logger, :to => :Rails
+
+    def initialize(app_instance, host_ids)
+      @app_instance = app_instance
+      @host_ids = host_ids
+    end
+
+    # TODO: this might be part of the smart proxy plugin.
+    def create_inventory
+      inventory = {}
+      inventory['all'] = {}
+
+      inventory['all'] = { 'vars' => inventory_all_vars } unless @app_instance.ansible_vars_all.nil? || @app_instance.ansible_vars_all.empty?
+
+      services = JSON.parse(@app_instance.app_definition.services)
+      app_hosts = filtered_hosts
+
+      children = {}
+      app_hosts.each do |host_data|
+        if host_data['foreman_host_id'].nil?
+          logger.warn "Ignore host #{host_data['hostname']} because no foreman host id could be found. Is the host not provisioned yet?"
+          next
+        end
+
+        service_id = host_data['service'].to_i
+        host_service = services.select { |s| s['id'] == service_id }.first
+        ansible_group = host_service['ansibleGroup']
+
+        unless children.has_key?(host_service['ansibleGroup'])
+          children[ansible_group] = { 'hosts' => {} }
+        end
+
+        ansible_vars = host_data['ansibleParameters'].map { |v| { v['name'] => v['value'] } }.reduce({}, :merge!)
+
+        # in case there is no ansible_user defined, set "root" as default.
+        unless ansible_vars.has_key?('ansible_user')
+          ansible_vars['ansible_user'] = 'root'
+        end
+
+        children[ansible_group]['hosts'][get_fqdn(host_data['foreman_host_id'])] = ansible_vars
+      end
+      inventory['all']['children'] = children
+      inventory
+    end
+
+    private
+    def inventory_all_vars
+      JSON.parse(@app_instance.ansible_vars_all).map do |a|
+        { a['name'] => a['value'] }
+      end.reduce({}, :merge!)
+    end
+
+    def get_fqdn(host_id)
+      Host.find(host_id)&.name
+    end
+
+    def filtered_hosts
+      JSON.parse(@app_instance.hosts).select{ |h| h&.key?('foreman_host_id') && @host_ids.include?(h['foreman_host_id']) }
+    end
+  end
+end

data/app/views/foreman_acd/ansible_playbooks/_form.html.erb

@@ -0,0 +1,21 @@
+<%= form_for @ansible_playbook, :url => (@ansible_playbook.new_record? ? ansible_playbooks_path : ansible_playbook_path(:id => @ansible_playbook.id)) do |f| %>
+  <%= base_errors_for @ansible_playbook %>
+
+  <ul class="nav nav-tabs" data-tabs="tabs">
+    <li class="active"><a href="#primary" data-toggle="tab"><%= _('Ansible playbooks') %></a></li>
+  </ul>
+
+  <div class="tab-content">
+    <div class="tab-pane active" id="primary">
+      <%= text_f f, :name %>
+      <%= text_f f, :description %>
+      <%= f.hidden_field :scm_type, :value => 'directory' %>
+      <% # TODO:
+         # select_f(f, :scm_type, %w[Directory GIT], :downcase, :to_s)
+      %>
+      <%= text_f f, :path %>
+      <%= text_f f, :playfile %>
+  </div>
+
+  <%= submit_or_cancel f %>
+<% end %>