foreman_opentofu 0.0.1

data/README.md

@@ -0,0 +1,134 @@
+[![Ruby Tests](https://github.com/ATIX-AG/foreman_opentofu/actions/workflows/ruby.yml/badge.svg)](https://github.com/ATIX-AG/foreman_opentofu/actions/workflows/ruby.yml)
+
+# ForemanOpenTOFU
+
+[Foreman](http://theforeman.org/) plugin that adds that adds a generic openTOFU-based compute resource, enabling host provisioning through openTOFU scripts instead of provider-specific SDK integrations such as fog-vsphere.
+
+This plugin introduces a new provisioning model where Foreman remains responsible for host lifecycle and orchestration, while openTOFU handles infrastructure creation using its provider ecosystem.
+
+The plugin is designed to be easily extendable and can support multiple infrastructure platforms (for example Nutanix, Hetzner) without requiring a dedicated Foreman compute resource plugin per provider.
+
+## Installation
+
+
+## Usage
+Create a openTofu compute resource and set:
+  * Provider: openTofu
+  * Opentofu Provider: Select desired hypervisor supported by openTofu plugin
+  * URL: Hypervisor specific URL
+    
+
+Then add all necessary information to the form.
+
+Provisioning workflow:
+
+ * Create a host in Foreman using the openTOFU based compute resource
+
+ * Foreman passes host parameters to the plugin
+
+ * The plugin renders and executes openTOFU plans
+
+ * openTOFU provisions the infrastructure
+
+ * Foreman continues with OS provisioning and configuration
+
+Provider-specific details (for example Nutanix, Hetzner) are handled entirely through openTOFU scripts.
+
+## Development
+
+### Dev prerequisites
+
+> See [Foreman dev setup](https://github.com/theforeman/foreman/blob/develop/developer_docs/foreman_dev_setup.asciidoc)
+
+* You need a openTOFU installed on your machine.
+* You need ruby 2.7. You can install it with [asdf-vm](https://asdf-vm.com).
+
+### Platform
+
+* Fork this github repo.
+* Clone it on your local machine
+* Install foreman v2.5+ on your machine:
+
+```shell
+git clone https://github.com/theforeman/foreman -b develop
+```
+
+* Create a Gemfile.local.rb file in foreman/bundler.d/
+* Add this line:
+
+```ruby
+gem 'foreman_opentofu', :path => '../../theforeman/foreman_opentofu'
+```
+
+* In foreman directory, install dependencies:
+
+```shell
+gem install bundler
+# prerequisites libraries on Ubuntu OS:
+bundle install
+```
+
+* You can reset and change your admin password if needed:
+
+```shell
+RAILS_ENV=development bundle exec bin/rake permissions:reset password=changeme
+```
+
+* In foreman_openTofu source directory, check code syntax with rubocop and foreman rules:
+
+```shell
+bundle exec rubocop
+```
+
+safe autocorrect:
+
+```shell
+bundle exec rubocop -a
+```
+
+Temporary ignore offenses:
+
+```shell
+bundle exec rubocop --auto-gen-config
+```
+
+* See deface overrides result:
+
+```shell
+bundle exec bin/rake deface:get_result['hosts/_compute_detail']
+```
+
+* In foreman directory, after you modify foreman_opentofu translations (language, texts in new files, etc) you have to compile it:
+
+Prerequisites: [Transifex CLI](https://github.com/transifex/cli)
+
+```shell
+bundle exec bin/rake plugin:gettext\[foreman_opentofu\]
+```
+
+* In foreman directory, run rails server:
+
+```shell
+bundle exec bin/rails server
+```
+
+* Or you can launch all together:
+
+```shell
+bundle exec foreman start
+```
+
+See details in [foreman plugin development](https://projects.theforeman.org/projects/foreman/wiki/How_to_Create_a_Plugin)
+
+## Contributing
+
+Fork and send a Pull Request or create Issue. Thank you.
+
+## Copyright
+Copyright (c) 2026 ATIX AG - http://www.atix.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 the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

data/Rakefile

@@ -0,0 +1,30 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+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 LoadError
+  puts 'Rubocop not loaded.'
+end
+
+task :default do
+  Rake::Task['rubocop'].execute
+end

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

@@ -0,0 +1,52 @@
+module Api
+  module V2
+    class TfStatesController < ::Api::V2::BaseController
+      include ::Api::Version2
+
+      resource_description do
+        api_version 'v2'
+        api_base_url '/foreman_opentofu/api'
+      end
+
+      skip_before_action :verify_authenticity_token
+      def show
+        state = ForemanOpentofu::TfState.find_by(name: params[:name])
+        if state
+          render plain: state.state, content_type: 'application/json'
+        else
+          render plain: '', status: :not_found
+        end
+      end
+
+      def create
+        state = ForemanOpentofu::TfState.find_or_create_by(name: params[:name])
+
+        raw_state = request.body.read
+        if raw_state.blank?
+          render plain: 'Missing state body', status: :unprocessable_entity
+          return
+        end
+        begin
+          JSON.parse(raw_state)
+
+          state.state = raw_state
+          state.save!
+          render plain: '', status: :ok
+        rescue JSON::ParserError => e
+          Rails.logger.error("Invalid state JSON: #{e.message}")
+          render plain: 'Invalid state format', status: :unprocessable_entity
+        end
+      end
+
+      def destroy
+        state = ForemanOpentofu::TfState.find_by(name: params[:name])
+        state&.destroy
+        render plain: '', status: :ok
+      end
+
+      def resource_class
+        @resource_class ||= ForemanOpentofu::TfState
+      end
+    end
+  end
+end

data/app/controllers/concerns/foreman_opentofu/compute_resources_vms_controller.rb

@@ -0,0 +1,17 @@
+module ForemanOpentofu
+  module ComputeResourcesVmsController
+    extend ActiveSupport::Concern
+    included do
+      prepend Overrides
+    end
+    module Overrides
+      def load_vms
+        if @compute_resource.is_a?(ForemanOpentofu::Tofu)
+          @vms = []
+          return
+        end
+        super
+      end
+    end
+  end
+end

data/app/controllers/concerns/foreman_opentofu/controller/parameters/compute_resource.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# Copyright 2018 Tristan Robert
+
+# This file is part of ForemanFogProxmox.
+
+# ForemanFogProxmox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# ForemanFogProxmox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with ForemanFogProxmox. If not, see <http://www.gnu.org/licenses/>.
+
+module ForemanOpentofu
+  module Controller
+    module Parameters
+      module ComputeResource
+        extend ActiveSupport::Concern
+
+        class_methods do
+          def compute_resource_params_filter
+            super.tap do |filter|
+              filter.permit :endpoint,
+                :opentofu_provider,
+                :username
+            end
+          end
+
+          def compute_resource_params
+            self.class.compute_resource_params_filter.filter_params(params, parameter_filter_context)
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/foreman_opentofu/concerns/base_template_scope_extensions.rb

@@ -0,0 +1,89 @@
+module ForemanOpentofu
+  module Concerns
+    module BaseTemplateScopeExtensions
+      extend ActiveSupport::Concern
+      extend ApipieDSL::Module
+
+      apipie :class, 'Base macros related to Opentofu templates' do
+        name 'Base Content'
+        sections only: %w[all provisioning]
+      end
+
+      apipie :method, 'Returns all VM parameters' do
+        required :skip_list, Array, desc: 'List of parameters to skip'
+        returns String, desc: '"key = value" lines'
+      end
+
+      def vm_attributes(skip_list = [])
+        available_attributes = @compute_resource.available_attributes
+        res = ''
+        @cr_attrs.each do |key, value|
+          next if skip_list.include? key
+
+          conf = available_attributes[key]
+          if conf.nil?
+            Rails.logger.warn("Attribute #{key.inspect} is not supported.")
+            next
+          end
+          next if conf['group'] != 'vm'
+          next if value.blank? && !conf['mandatory']
+
+          res << "#{key} = #{format_value(value, conf['type'])}\n"
+        end
+        res << nic_attributes(available_attributes)
+      end
+
+      def nic_attributes(available_attributes)
+        interfaces = @cr_attrs['interfaces'] || @cr_attrs['interfaces_attributes']
+        return '' if interfaces.blank?
+
+        interfaces = normalize_interfaces(interfaces)
+        nic_defs = available_attributes.values.select do |attrs|
+          attrs['group'] == 'nic'
+        end
+        res = ''
+        interfaces.each do |iface|
+          next if iface['subnet_uuid'].blank?
+
+          res << build_attribute_block('nic_list', iface, nic_defs)
+        end
+        res
+      end
+
+      def normalize_interfaces(interfaces)
+        if interfaces.is_a?(Hash)
+          if interfaces.keys.all? { |k| k.to_s =~ /^\d+$/ }
+            interfaces.values
+          else
+            [interfaces]
+          end
+        else
+          Array(interfaces)
+        end
+      end
+
+      def build_attribute_block(block_name, attrs, nic_defs)
+        res = "#{block_name} {\n"
+        attrs.each do |k, v|
+          next if v.blank?
+          conf = nic_defs.find { |a| (a['name'] || a[:name]) == k }
+          next unless conf
+          res << "  #{k} = #{format_value(v, conf['type'])}\n" if conf
+        end
+        res << "}\n"
+        res
+      end
+
+      private
+
+      def format_value(val, type)
+        case type
+        when 'string', 'select' then "\"#{val}\""
+        when 'bool' then Foreman::Cast.to_bool(val)
+        when 'number' then val.to_i
+        else val
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/orchestration/tofu/compute.rb

@@ -0,0 +1,24 @@
+module Orchestration
+  module Tofu
+    module Compute
+      extend ActiveSupport::Concern
+
+      def computeValue(_foreman_attr, fog_attr)
+        value = ''
+        value += vm.send(fog_attr).to_s
+        value
+      end
+
+      def match_macs_to_nics(fog_attr)
+        interfaces.select(&:physical?).each do |nic|
+          mac = vm.send(fog_attr)
+          logger.debug "Orchestration::Compute: nic #{nic.inspect} assigned to #{vm.inspect}"
+          nic.mac = mac
+          nic.reset_dhcp_record_cache if nic.respond_to?(:reset_dhcp_record_cache) # delete the cached dhcp_record with old MAC on managed nics
+          return false unless validate_required_foreman_attr(mac, Nic::Base.physical, :mac)
+        end
+        true
+      end
+    end
+  end
+end

data/app/models/foreman_opentofu/compute_vm.rb

@@ -0,0 +1,99 @@
+module ForemanOpentofu
+  class ComputeVM
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+
+    def initialize(provider, attrs = {})
+      @attributes = flatten_attrs(attrs.deep_stringify_keys)
+      @provider = provider
+      define_dynamic_readers!
+    end
+
+    def [](key)
+      @attributes[key.to_s]
+    end
+
+    def to_h
+      unwrap(@attributes.to_dup)
+    end
+
+    def power
+      self['power'] || self['power_state']
+    end
+
+    # TODO: add definitions for different power on/off values
+    def ready?
+      power.to_s == 'on'
+    end
+
+    def name
+      self['name']
+    end
+
+    def start
+      @provider.start_vm(name)
+    end
+
+    def stop
+      @provider.stop_vm(name)
+    end
+
+    def reboot
+      stop
+      start
+    end
+
+    def reset
+      reboot
+    end
+
+    private
+
+    def define_dynamic_readers!
+      @attributes.each_key do |key|
+        next if respond_to?(key)
+
+        define_singleton_method(key) do
+          @attributes[key]
+        end
+      end
+    end
+
+    def deep_wrap(value)
+      case value
+      when Hash
+        value.transform_values { |v| deep_wrap(v) }
+      when Array
+        value.map { |v| deep_wrap(v) }
+      else
+        value
+      end
+    end
+
+    def flatten_attrs(attrs)
+      result = {}
+
+      attrs.each do |key, value|
+        if key.to_s == 'vm' && value.is_a?(Hash)
+          # Merge the "vm" hash into the top-level
+          result.merge!(value)
+        else
+          result[key] = value
+        end
+      end
+
+      result
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @attributes.key?(method_name.to_s) || super
+    end
+
+    def method_missing(method_name, *args)
+      key = method_name.to_s
+      return @attributes[key] if @attributes.key?(key)
+
+      super
+    end
+  end
+end

data/app/models/foreman_opentofu/opentofu_vm_commands.rb

@@ -0,0 +1,88 @@
+module ForemanOpentofu
+  module OpentofuVMCommands
+    def find_vm_by_uuid(uuid)
+      vm_command_errors('find vm') do
+        tf_state = ForemanOpentofu::TfState.find_by(uuid: uuid)
+        data = client({ 'name' => tf_state&.name }).run('output')
+        ComputeVM.new(self, data)
+      end
+    end
+
+    def new_vm(args = {})
+      vm_command_errors('new vm') do
+        args = default_attributes.merge(args)
+        executor = client(args)
+        data = executor.run('new')
+        OpenStruct.new(data['resource_changes'].first['change']['after'])
+      end
+    end
+
+    def create_vm(args = {})
+      vm_command_errors('create vm') do
+        args = default_attributes.merge(args)
+        executor = client(args)
+        output = executor.run('create')
+        ComputeVM.new(self, output)
+      end
+    end
+
+    def destroy_vm(uuid)
+      tf_state = ForemanOpentofu::TfState.find_by(uuid: uuid)
+      client({ 'name' => tf_state&.name }).run('destroy')
+      return unless tf_state
+
+      Rails.logger.info "Deleting tfstate for #{tf_state&.name}"
+      tf_state.destroy
+    end
+
+    def start_vm(name)
+      output = client({ 'name' => name, 'power_state' => 'on' }).run('create')
+      output['vm']['power_state'] == 'on'
+    end
+
+    def stop_vm(name)
+      output = client({ 'name' => name, 'power_state' => 'off' }).run('create')
+      output['vm']['power_state'] == 'off'
+    end
+
+    def save_vm(uuid, attrs)
+      tf_state = TfState.find_by(uuid: uuid)
+      raise StandardError, "VM with UUID #{uuid} does not exist" unless tf_state
+      vm_command_errors('update vm') do
+        attrs = attrs.empty? ? {} : attrs.first
+        data = client({ 'name' => tf_state.name }.merge(attrs)).run('create')
+        ComputeVM.new(self, data)
+      end
+    end
+
+    def test_connection(options = {})
+      super
+      begin
+        client.run('test_connection')
+      rescue StandardError => e
+        Rails.logger.error("OpenTofu test connection failed: #{e.message}")
+        errors.add(:base, e.message)
+      end
+    end
+
+    private
+
+    def vm_command_errors(method_name)
+      yield
+    rescue StandardError => e
+      Foreman::Logging.exception("Caught #{provider} error", e)
+      raise ::Foreman::WrappedException.new(
+        e,
+        N_(
+          "Foreman could not find a required %<provider>s resource in #{method_name}. " \
+          'Check if Foreman has the required permissions and the resource exists. Reason: %<error>s'
+        ),
+        { provider: provider, error: e.message }
+      )
+    end
+
+    def client(args = {})
+      OpentofuExecuter.new(self, args)
+    end
+  end
+end

data/app/models/foreman_opentofu/tf_state.rb

@@ -0,0 +1,8 @@
+module ForemanOpentofu
+  class TfState < ApplicationRecord
+    # DO we need this name or change it to foreman_opentofu_tf_states
+    self.table_name = 'tf_states'
+
+    validates :name, presence: true, uniqueness: true
+  end
+end

data/app/models/foreman_opentofu/tofu.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+# This file is part of ForemanOpentofu.
+
+# ForemanOpentofu is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# ForemanOpentofu is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with ForemanOpentofu. If not, see <http://www.gnu.org/licenses/>.
+
+module ForemanOpentofu
+  class Tofu < ComputeResource
+    include OpentofuVMCommands
+    validates :provider, presence: true, inclusion: { in: %w[Tofu] }
+    validates :url, presence: true
+    validates :user, presence: true
+    validates :password, presence: true
+
+    # alias_attribute :username, :user
+    # alias_attribute :endpoint, :url
+
+    delegate :available_attributes, to: :tofu_provider
+
+    def provided_attributes
+      super.merge(
+        mac: :mac
+      )
+    end
+
+    def opentofu_provider
+      attrs[:opentofu_provider]
+    end
+
+    def opentofu_provider=(value)
+      attrs[:opentofu_provider] = value
+    end
+
+    def self.provider_friendly_name
+      'OpenTofu'
+    end
+
+    def capabilities
+      [:build]
+    end
+
+    def self.model_name
+      ComputeResource.model_name
+    end
+
+    def default_attributes
+      {}
+    end
+
+    def supports_update?
+      true
+    end
+
+    def tofu_provider
+      ProviderTypeManager.find(opentofu_provider)
+    end
+
+    def new_interface
+      { compute_attributes: {} }
+    end
+
+    def editable_network_interfaces?
+      true
+    end
+  end
+end

data/app/overrides/compute_resources/remove_virtual_machines_tab.rb

@@ -0,0 +1,8 @@
+Deface::Override.new(
+  virtual_path: 'compute_resources/show',
+  name: 'remove_virtual_machines_tab',
+  replace: "li:has(a[href='#vms'])",
+  text: '<% if @compute_resource.class != ForemanOpentofu::Tofu %><li><a href="#vms" data-toggle="tab"><%= _("Virtual Machines") %></a></li> <% end %>',
+  original: '15da4ffe56b9d3155f0d037ddffb7653479ee0c8',
+  namespaced: true
+)