foreman_opentofu 0.0.1

data/app/services/foreman_opentofu/app_wrapper.rb

@@ -0,0 +1,107 @@
+module ForemanOpentofu
+  class AppWrapper
+    attr_reader :workdir, :planfile, :conffile
+
+    # TODO: for future versions
+    #   - manage temp-work-dir; problem: no auto-remove after finished :-(
+    #   - handle ENVVars if applicable
+    #   - handle stderr and stdout separately
+    #   - use JSON-output for easier parsing
+    #   - do we need locking or has the object be atomic
+
+    def initialize(workdir)
+      @workdir = workdir
+      @planfile = File.join(workdir, 'plan.bin')
+      @conffile = File.join(workdir, 'main.tf')
+    end
+
+    def base_command
+      'tofu'
+    end
+
+    def default_params
+      [
+        '-no-color',
+      ]
+    end
+
+    # optional: specify block to access command-pipe (object of class `IO`), e.g.
+    # tofu.init do |t|
+    #   until t.eof? do
+    #     puts("Message from Tofu: #{t.gets}")
+    #   end
+    # end
+    def init(params = [], &block)
+      tofu_execute('init', ['-input=false'].concat(parse_params(params)), &block)
+    end
+
+    def plan(params = [])
+      tofu_execute('plan', ["-out=#{planfile}"].concat(parse_params(params)))
+    end
+
+    def apply(params = [])
+      tofu_execute('apply', ['-auto-approve'].concat(parse_params(params)))
+    end
+
+    def destroy(params = [])
+      tofu_execute('destroy', ['-auto-approve'].concat(parse_params(params)))
+    end
+
+    def output(params = [])
+      JSON.parse(tofu_execute('output', ['-json'].concat(parse_params(params))))
+    end
+
+    # TODO: find better name ;-)
+    def show_plan(params = [])
+      JSON.parse(tofu_execute('show', ['-json', planfile].concat(parse_params(params))))
+    end
+
+    def main_configuration
+      File.read(conffile)
+    end
+
+    def main_configuration=(config)
+      File.write(conffile, config)
+    end
+
+    private
+
+    def parse_params(params)
+      params.is_a?(String) ? [params] : params
+    end
+
+    def tofu_execute(action, params = [], &block)
+      execute [base_command, action].concat(default_params).concat(params), &block
+    end
+
+    def command(cmd)
+      cmd.map { |item| "'#{item}'" }.append('2>&1').join(' ')
+    end
+
+    def execute(cmd)
+      output = nil
+      # quote cmdline parameters and add stderr to stdout
+      commandline = command(cmd)
+      Dir.chdir(workdir) do
+        Rails.logger.debug "Start command: #{commandline.inspect}"
+        IO.popen(commandline, 'r+') do |pipe|
+          if block_given?
+            yield pipe
+          else
+            output = pipe.read
+          end
+        end
+      end
+      ret = $CHILD_STATUS
+      Rails.logger.info "#{cmd} returned #{ret.inspect}"
+      Rails.logger.debug output.to_s
+      unless ret.success?
+        Rails.logger.error "Command failed with output: #{output}"
+        # TODO: do we need to use a specific exception-type here?
+        raise "command failed with code #{ret.exitstatus}:\n#{output}"
+      end
+
+      output
+    end
+  end
+end

data/app/services/foreman_opentofu/compute_fetcher.rb

@@ -0,0 +1,51 @@
+module ForemanOpentofu
+  class ComputeFetcher
+    def self.fetch_subnets(compute_resource)
+      return [] unless compute_resource == 'Nutanix'
+      attrs = []
+      Dir.mktmpdir('opentofu_') do |dir|
+        tofu = ForemanOpentofu::AppWrapper.new(dir)
+        tofu.main_configuration = tf_content(compute_resource)
+        tofu.init
+        tofu.apply
+        attrs = tofu.output('subnets')
+      end
+      attrs.map { |h| OpenStruct.new(h) }
+    rescue StandardError => e
+      Rails.logger.error("Failed to fetch subnets: #{e}")
+      []
+    end
+
+    def self.tf_content(compute_resource)
+      <<~HCL
+        terraform {
+          required_providers {
+            nutanix = {
+              source  = "nutanix/nutanix"
+              version = ">=1.6.0"
+            }
+          }
+        }
+
+        provider "nutanix" {
+          username = "#{compute_resource.user}"
+          password = "#{compute_resource.password}"
+          endpoint = "#{compute_resource.url}"
+          insecure = true
+        }
+
+        # Fetch all subnets
+        data "nutanix_subnets" "all" {}
+
+        output "subnets" {
+          value = [
+            for s in data.nutanix_subnets.all.entities : {
+              id = s.metadata.uuid
+              name = s.name
+            }
+          ]
+        }
+      HCL
+    end
+  end
+end

data/app/services/foreman_opentofu/opentofu_executer.rb

@@ -0,0 +1,78 @@
+require 'json'
+
+module ForemanOpentofu
+  class OpentofuExecuter
+    def initialize(*args)
+      @compute_resource = args[0]
+      @cr_attrs = args[1] || {}
+    end
+
+    def run(mode = 'create')
+      Dir.mktmpdir('opentofu_') do |dir|
+        tofu = AppWrapper.new(dir)
+        @use_backend = %w[create destroy output].include?(mode)
+        tofu.main_configuration = render_template
+        tofu.init
+        run_mode(tofu, mode)
+      end
+    end
+
+    def run_mode(tofu, mode = 'new')
+      @use_backend = true
+      case mode
+      when 'new'
+        tofu.plan
+        tofu.show_plan
+      when 'test_connection'
+        tofu.plan
+      when 'create'
+        tofu.plan
+        tofu.apply
+        attrs = tofu.output('vm_attrs')
+        ForemanOpentofu::TfState.find_by(name: @cr_attrs['name'])&.update(uuid: attrs['identity'])
+        attrs
+      when 'output'
+        tofu.output('vm_attrs')
+      when 'destroy'
+        tofu.destroy
+      else
+        raise "Please select one of the modes: 'new', 'test_connection', 'create' or 'destroy'"
+      end
+    end
+
+    private
+
+    def render_template
+      template = provision_template
+      scope = Foreman::Renderer.get_scope(source: template)
+      source = Foreman::Renderer.get_source(template: template)
+      scope.instance_variable_set(:@compute_resource, @compute_resource)
+      scope.instance_variable_set(:@cr_attrs, @cr_attrs) if @cr_attrs
+      scope.instance_variable_set(:@use_backend, @use_backend)
+      rendered_template = Foreman::Renderer::UnsafeModeRenderer.render(source, scope)
+      raise ::Foreman::Exception, N_('Unable to render provisioning template') unless rendered_template
+
+      rendered_template
+    end
+
+    def provision_template
+      name = ''
+      provider = @compute_resource.opentofu_provider
+      case provider
+      when 'nutanix'
+        name = Setting[:provision_nutanix_host_template]
+      when 'ovirt'
+        name = Setting[:provision_ovirt_host_template]
+      when 'vsphere'
+        name = Setting[:provision_vsphere_host_template]
+      end
+      template = ProvisioningTemplate.unscoped.find_by(name: name)
+      unless template
+        raise ::Foreman::Exception.new(N_('Unable to find template specified by %s setting'),
+          name)
+      end
+
+      template
+    end
+  end
+end

data/app/services/foreman_opentofu/provider_type.rb

@@ -0,0 +1,30 @@
+module ForemanOpentofu
+  class ProviderType
+    attr_reader :id, :name
+
+    def initialize(id)
+      @id = id.to_sym
+      @name = id.capitalize
+    end
+
+    # returns hash of available-attributes with attr-name as key
+    def available_attributes
+      raise "No available-attributes found for #{name}" unless attributes?
+
+      attributes&.index_by { |e| e['name'] }
+    end
+
+    def attributes?
+      CR_ATTRS.key? id.to_s
+    end
+
+    def attributes(group = nil)
+      return nil unless CR_ATTRS.key? id.to_s
+
+      a = CR_ATTRS[id.to_s]
+      return a if group.nil?
+
+      a.select { |e| e['group'] == group }
+    end
+  end
+end

data/app/services/foreman_opentofu/provider_type_manager.rb

@@ -0,0 +1,36 @@
+module ForemanOpentofu
+  class ProviderTypeManager
+    @defined_provider_types = {}
+
+    class << self
+      private :new
+      attr_reader :defined_provider_types
+
+      # Plugin constructor
+      def register(id, &block)
+        defined_prov_type = find_defined(id)
+        return if defined_prov_type.present?
+
+        defined_prov_type = ::ForemanOpentofu::ProviderType.new(id)
+        defined_prov_type.instance_eval(&block) if block_given?
+        @defined_provider_types[id.to_s] = defined_prov_type
+      end
+
+      def find(provider_type)
+        find_defined(provider_type)
+      end
+
+      def find_defined(provider_type)
+        @defined_provider_types[provider_type.to_s]
+      end
+
+      def enabled_provider_type_names
+        @defined_provider_types.values.map(&:name)
+      end
+
+      def enabled_provider_types
+        @defined_provider_types.values
+      end
+    end
+  end
+end

data/app/views/compute_resources/form/_tofu.html.erb

@@ -0,0 +1,9 @@
+<%= field_set_tag _("Common fields"), :id => "compute_ressource_common_field_set" do %>
+  <%= select_f f, :opentofu_provider, ForemanOpentofu::ProviderTypeManager.enabled_provider_types, :id, :name %>
+  <%= text_f f, :url, :help_block => _("127.0.0.1") %>
+  <%= text_f f, :user , :help_block => _("e.g. admin") %>
+  <%= password_f f, :password  %>
+<% end %>
+<div class="col-md-offset-2">
+  <%= test_connection_button_f(f, (true)) %>
+</div>

data/app/views/compute_resources/show/_tofu.html.erb

@@ -0,0 +1,8 @@
+<tr>
+  <td><%= _('OpenTofu Provider') %></td>
+  <td><%= @compute_resource.opentofu_provider %></td>
+</tr>
+<tr>
+  <td><%= _('URL') %></td>
+  <td><%= @compute_resource.url %></td>
+</tr>

data/app/views/compute_resources_vms/form/tofu/_base.html.erb

@@ -0,0 +1,13 @@
+<% provider = compute_resource.tofu_provider %>
+<% if provider.attributes.present? %>
+  <% vm_attrs   = provider.attributes('vm') %>
+  <% disk_attrs = provider.attributes('disk') %>
+  <%= field_set_tag _("VM Config") do %>
+    <%= render :partial => provider_partial(compute_resource, "dynamic_attrs"), :locals => { f: f, attrs: vm_attrs } %>
+  <% end %>
+
+  <%= field_set_tag _("Storage") do %>
+    <%= render :partial => provider_partial(compute_resource, "dynamic_attrs"), :locals => { f: f, attrs: disk_attrs } %>
+  <% end %>
+<% end %>
+

data/app/views/compute_resources_vms/form/tofu/_dynamic_attrs.html.erb

@@ -0,0 +1,18 @@
+<% attrs.each do |attr|
+  label = attr.fetch('label', attr['name'].humanize) %>
+
+  <% case attr["type"] %>
+  <% when 'string' %>
+    <%= text_f f, attr["name"].to_sym, label: _(label), label_help: attr['help'] %>
+  <% when 'bool' %>
+    <%= checkbox_f f, attr["name"].to_sym, label: _(label), label_help: attr['help'] %>
+  <% when 'number' %>
+    <%= counter_f f, attr["name"].to_sym, label: _(label), label_help: attr['help'] %>
+  <% when 'select' %>
+    <% if attr.key? 'options' %>
+      <%= select_f f, attr["name"].to_sym, attr.fetch('options', []), :to_s, :to_s, { :include_blank => true }, label: _(label), label_help: attr['help'] %>
+    <% else  %>
+      <%= select_f f, attr["name"].to_sym, (options || []), :id, :name, { :include_blank => true }, label: _(label), label_help: attr['help'] %>
+    <% end %>
+  <% end %>
+<% end %>

data/app/views/compute_resources_vms/form/tofu/_network.html.erb

@@ -0,0 +1,5 @@
+<% provider = compute_resource.opentofu_provider.to_s %>
+<% if CR_ATTRS.key?(provider) %>
+  <% nic_attrs = CR_ATTRS[provider].select { |a| a["group"] == "nic" } %>
+  <%= render :partial => provider_partial(compute_resource, "dynamic_attrs"), :locals => { f: f, attrs: nic_attrs, options: ForemanOpentofu::ComputeFetcher.fetch_subnets(compute_resource) } %>
+<% end %>

data/app/views/templates/provisioning/nutanix_provision_host.erb

@@ -0,0 +1,51 @@
+#!/bin/bash
+<%#
+kind: script
+name: Nutanix provision - host
+model: ProvisioningTemplate
+description: |
+  nutanix opentofu script to create vm resource
+-%>
+<%-
+host_name = @cr_attrs['name'] || 'test'
+%>
+
+terraform {
+  required_providers {
+    nutanix = {
+      source = "nutanix/nutanix"
+    }
+  }
+  <% if @use_backend %>
+    backend "http" {
+      address        = "<%= Setting[:foreman_url] %>/api/v2/tf_states/<%= host_name %>"
+      username       = "admin"
+      password       = "changeme"
+    }
+  <% end %>
+}
+
+provider "nutanix" {
+    username = "<%= @compute_resource['user'] %>"
+    password = "<%= @compute_resource['password'] %>"
+    endpoint = "<%= @compute_resource['url'] %>"
+    insecure = true
+}
+
+data "nutanix_clusters" "clusters" {}
+
+resource "nutanix_virtual_machine" "vm" {
+  cluster_uuid = data.nutanix_clusters.clusters.entities.0.metadata.uuid
+  name         = "<%= host_name %>"
+
+  <%= vm_attributes(['name', 'cluster_uuid']) %>
+
+}
+
+output "vm_attrs" {
+  value = {
+      identity = nutanix_virtual_machine.vm.id
+      mac = nutanix_virtual_machine.vm.nic_list[0].mac_address
+  }
+}
+

data/app/views/templates/provisioning/ovirt_provision_host.erb

@@ -0,0 +1,68 @@
+#!/bin/bash
+<%#
+kind: script
+name: Ovirt provision - host
+model: ProvisioningTemplate
+description: |
+  nutanix opentofu script to create vm resource
+-%>
+<%-
+host_name = @cr_attrs['name'] || 'test'
+%>
+
+terraform {
+  required_providers {
+    ovirt = {
+      source = "ovirt/ovirt"
+    }
+  }
+  <% if @use_backend %>
+    backend "http" {
+      address        = "<%= Setting[:foreman_url] %>/api/v2/tf_states/<%= host_name %>"
+      username       = "admin"
+      password       = "changeme"
+    }
+  <% end %>
+}
+
+provider "ovirt" {
+  username = "<%= @compute_resource['user'] %>"
+  password = "<%= @compute_resource['password'] %>"
+  url = "<%= @compute_resource['url'] %>"
+  tls_insecure = true
+}
+
+data "ovirt_blank_template" "blank" {
+}
+
+resource "ovirt_vm" "vm" {
+  name        = "<%= host_name %>"
+  cluster_id  = "2ad616ea-4b66-11f0-964d-901b0ecbd584"
+  template_id = data.ovirt_blank_template.blank.id
+  cpu_cores   = <%= @cr_attrs['cpu_cores'] || 1 %>
+  cpu_sockets = <%= @cr_attrs['cpu_sockets'] || 1 %>
+  cpu_threads = <%= @cr_attrs['cpu_threads'] || 1 %>
+  memory      = <%= @cr_attrs['memory'] || 400000 %>
+  maximum_memory = <%= @cr_attrs['maximum_memory'] || 4000000 %>
+  memory_ballooning = <%= @cr_attrs['memory_ballooning'] || false %>
+}
+resource "ovirt_vm" "vm" {
+  name        = "<%= host_name %>"
+  cluster_id  = "2ad616ea-4b66-11f0-964d-901b0ecbd584"
+  template_id = data.ovirt_blank_template.blank.id
+  <%= "cpu_cores = #{@cr_attrs['cpu_cores'] || 1}" %>
+  <%= "cpu_sockets = #{@cr_attrs['cpu_sockets'] || 1}" %>
+  <%= "cpu_threads = #{@cr_attrs['cpu_threads'] || 1}" %>
+  <%= "cpu_mode = \"#{@cr_attrs['cpu_mode']}\"" if @cr_attrs['cpu_mode'].present? %>
+  <%= "memory = #{@cr_attrs['memory'] || 400000}" %>
+  <%= "maximum_memory = #{@cr_attrs['maximum_memory'] || 4000000}" %>
+  <%= "memory_ballooning = #{@cr_attrs['memory_ballooning']}" if @cr_attrs.key?('memory_ballooning') %>
+  <%= "id = \"#{@cr_attrs['id']}\"" if @cr_attrs['id'].present? %>
+  <%= "os_type = \"#{@cr_attrs['os_type']}\"" if @cr_attrs['os_type'].present? %>
+  <%= "soundcard_enabled = #{@cr_attrs['soundcard_enabled']}" if @cr_attrs.key?('soundcard_enabled') %>
+  <%= "vm_type = \"#{@cr_attrs['vm_type']}\"" if @cr_attrs['vm_type'].present? %>
+}
+
+output "uuid" {
+  value = ovirt_vm.vm
+}

data/config/initializers/compute_attrs.rb

@@ -0,0 +1,19 @@
+require 'json'
+
+CONFIG_DIR = File.expand_path(File.join(__dir__, '..'))
+
+# rubocop:disable Style/MutableConstant
+CR_ATTRS = {}
+# rubocop:enable Style/MutableConstant
+
+Dir["#{CONFIG_DIR}/*.{json,yaml,yml}"].each do |filename|
+  next unless File.exist?(filename)
+
+  file_content = File.read(filename)
+  provider = File.basename(filename, '.*')
+  CR_ATTRS[provider] = case File.extname(filename)
+                       when /\.json/i then JSON.parse(file_content)
+                       when /\.ya?ml/i then YAML.safe_load(file_content)
+                       else next
+                       end
+end

data/config/nutanix.json

@@ -0,0 +1,27 @@
+[
+  { "name": "num_sockets", "type": "number", "group": "vm", "mandatory": false,
+    "label": "Sockets" },
+  { "name": "num_vcpus_per_socket", "type": "number", "group": "vm", "mandatory": false,
+    "label": "Cores per socket" },
+  { "name": "memory_size_mib", "type": "number", "group": "vm", "mandatory": false,
+    "label": "Memory (MB)" },
+  { "name": "enable_cpu_passthrough", "label": "CPU Passthrough Enable", "type": "bool", "group": "vm", "mandatory": false },
+  { "name": "num_vnuma_nodes", "type": "number", "group": "vm", "mandatory": false,
+    "label": "vNUMA Nodes", "help": "Number of vNUMA nodes. 0 means vNUMA is disabled." },
+  { "name": "boot_type", "type": "select", "group": "vm", "mandatory": false,
+    "label": "Firmware", "options": [ "UEFI", "LEGACY", "SECURE_BOOT" ] },
+  { "name": "power_state", "type": "select", "group": "vm", "mandatory": false,
+    "options": [ "ON" , "OFF" ] },
+  { "name": "use_hot_add", "type": "bool", "group": "vm", "mandatory": false,
+    "help": "Use Hot Add when modifying VM resources. Passing value false will result in VM reboots. Default value is true." },
+  { "name": "vga_console_enabled", "type": "bool", "group": "vm", "mandatory": false,
+    "label": "VGA Console Enable" },
+  { "name": "disk_size_mib", "type": "number", "group": "disk", "mandatory": true,
+    "label": "Size (MB)" },
+  { "name": "nic_type", "type": "select", "group": "nic", "mandatory": false,
+    "label": "NIC Type", "options": [ "NORMAL_NIC", "DIRECT_NIC", "NETWORK_FUNCTION_NIC" ] },
+  { "name": "model", "type": "select", "group": "nic", "mandatory": true,
+    "options": [ "VIRTIO", "E1000" ] },
+  { "name": "subnet_uuid", "type": "select", "group": "nic", "mandatory": true,
+    "label": "Subnet" }
+]

data/config/ovirt.json

@@ -0,0 +1,18 @@
+[
+  { "name": "clone", "type": "bool", "group": "vm" },
+  { "name": "cluster_id", "type": "string", "group": "vm" },
+  { "name": "cpu_cores", "type": "number", "group": "vm" },
+  { "name": "cpu_mode", "type": "string", "group": "vm" },
+  { "name": "cpu_sockets", "type": "number", "group": "vm" },
+  { "name": "cpu_threads", "type": "number", "group": "vm" },
+  { "name": "id", "type": "string", "group": "vm" },
+  { "name": "maximum_memory", "type": "number", "group": "vm" },
+  { "name": "memory", "type": "number", "group": "vm" },
+  { "name": "memory_ballooning", "type": "bool", "group": "vm" },
+  { "name": "name", "type": "string", "group": "vm" },
+  { "name": "os_type", "type": "string", "group": "vm" },
+  { "name": "soundcard_enabled", "type": "bool", "group": "vm" },
+  { "name": "template_id", "type": "string", "group": "vm" },
+  { "name": "vm_type", "type": "string", "group": "vm" }
+]
+

data/config/routes.rb

@@ -0,0 +1,13 @@
+Rails.application.routes.draw do
+  namespace :api do
+    scope '(:apiv)',
+      module: :v2,
+      defaults: { apiv: 'v2' },
+      apiv: /v1|v2/,
+      constraints: ApiConstraints.new(version: 2, default: true) do
+      match 'tf_states/:name', to: 'tf_states#create', via: :post, constraints: { name: %r{[^/]+} }
+      match 'tf_states/:name', to: 'tf_states#show',    via: :get, constraints: { name: %r{[^/]+} }
+      match 'tf_states/:name', to: 'tf_states#destroy', via: :delete, constraints: { name: %r{[^/]+} }
+    end
+  end
+end

data/db/migrate/20250625192757_create_tf_state.foreman_opentofu.rb

@@ -0,0 +1,10 @@
+class CreateTfState < ActiveRecord::Migration[7.0]
+  def change
+    create_table :tf_states do |t|
+      t.string :name, limit: 255
+      t.string :uuid, limit: 255
+      t.text :state
+      t.timestamps
+    end
+  end
+end

data/db/seeds.d/71_provisioning_templates.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+User.as_anonymous_admin do
+  ProvisioningTemplate.without_auditing do
+    SeedHelper.import_templates(
+      Dir[File.join("#{ForemanOpentofu::Engine.root}/app/views/templates/provisioning/**/*.erb")]
+    )
+  end
+end

data/lib/foreman_opentofu/engine.rb

@@ -0,0 +1,75 @@
+module ForemanOpentofu
+  class Engine < ::Rails::Engine
+    isolate_namespace ForemanOpentofu
+    engine_name 'foreman_opentofu'
+
+    # Add any db migrations
+    initializer 'foreman_opentofu.load_app_instance_data' do |app|
+      ForemanOpentofu::Engine.paths['db/migrate'].existent.each do |path|
+        app.config.paths['db/migrate'] << path
+      end
+
+      app.config.autoload_paths += Dir["#{config.root}/app/services/foreman_opentofu"]
+    end
+
+    initializer 'foreman_opentofu.register_plugin', before: :finisher_hook do |app|
+      app.reloader.to_prepare do
+        Foreman::Plugin.register :foreman_opentofu do
+          requires_foreman '>= 3.0'
+          register_gettext
+
+          extend_template_helpers ForemanOpentofu::Concerns::BaseTemplateScopeExtensions
+          # Add Global files for extending foreman-core components and routes
+          # Register Nutanix compute resource in foreman
+          compute_resource ForemanOpentofu::Tofu
+          settings do
+            category :opentofu, N_('Opentofu') do
+              templates = lambda {
+                Hash[ProvisioningTemplate.where(template_kind: TemplateKind.where(name: 'script')).map do |temp|
+                       [temp[:name], temp[:name]]
+                     end ]
+              }
+
+              setting 'provision_nutanix_host_template',
+                type: :string,
+                collection: templates,
+                default: 'Nutanix provision - host',
+                full_name: N_('Nutanix Host provision template'),
+                description: N_('Opentofu script template to use for Nutanix based host provisioning')
+              setting 'provision_ovirt_host_template',
+                type: :string,
+                collection: templates,
+                default: 'Ovirt provision - host',
+                full_name: N_('Ovirt Host provision template'),
+                description: N_('Opentofu script template to use for Ovirt based host provisioning')
+              setting 'provision_vsphere_host_template',
+                type: :string,
+                collection: templates,
+                default: 'Vsphere provision - host',
+                full_name: N_('Vsphere Host provision template'),
+                description: N_('Opentofu script template to use for Vsphere based host provisioning')
+            end
+          end
+        end
+      end
+    end
+
+    config.autoload_paths << File.expand_path('../lib', __dir__)
+    # Include concerns in this config.to_prepare block
+    config.to_prepare do
+      ::ComputeResourcesController.include ForemanOpentofu::Controller::Parameters::ComputeResource
+      ::ComputeResourcesVmsController.include ForemanOpentofu::ComputeResourcesVmsController
+      ::Host::Managed.include Orchestration::Tofu::Compute
+    rescue StandardError => e
+      Rails.logger.warn "ForemanOpentofu: skipping engine hook (#{e})"
+    end
+
+    load 'foreman_opentofu/provider_types.rb'
+
+    rake_tasks do
+      Rake::Task['db:seed'].enhance do
+        ForemanOpentofu::Engine.load_seed
+      end
+    end
+  end
+end