foreman_opentofu 0.0.2 → 0.0.4

data/app/models/foreman_opentofu/tofu.rb

@@ -18,6 +18,7 @@
 module ForemanOpentofu
   class Tofu < ComputeResource
     include OpentofuVMCommands
+    include ComputeResourceCaching
     validates :provider, presence: true, inclusion: { in: %w[Tofu] }
     validates :url, presence: true
     validates :user, presence: true
@@ -26,12 +27,19 @@ module ForemanOpentofu
     # alias_attribute :username, :user
     # alias_attribute :endpoint, :url
 
-    delegate :available_attributes, to: :tofu_provider
+    delegate :available_attributes, :capabilities, :render_disk, :render_nic, to: :tofu_provider
+
+    def available_images
+      # make sure available_images can use this CR, e.g. for requesting data_source
+      tofu_provider.available_images(self)
+    end
 
     def provided_attributes
-      super.merge(
-        mac: :mac
-      )
+      super.merge(tofu_provider.provided_attributes || {})
+    end
+
+    def user_data_supported?
+      true
     end
 
     def opentofu_provider
@@ -60,10 +68,6 @@ module ForemanOpentofu
       'OpenTofu'
     end
 
-    def capabilities
-      [:build]
-    end
-
     def self.model_name
       ComputeResource.model_name
     end
@@ -76,16 +80,45 @@ module ForemanOpentofu
       true
     end
 
+    def vm_ready(vm)
+      return tofu_provider.vm_ready(vm) if tofu_provider.respond_to? :vm_ready
+
+      vm.wait_for { ready? }
+    end
+
     def tofu_provider
       ProviderTypeManager.find(opentofu_provider)
     end
 
-    def new_interface
-      { compute_attributes: {} }
+    def new_interface(attr = {})
+      OpenStruct.new(attr)
+    end
+
+    def new_volume(attr = {})
+      OpenStruct.new(attr.merge({}))
+    end
+
+    def default_volumes
+      tofu_provider&.default_volumes || {}
+    end
+
+    def default_interfaces
+      tofu_provider&.default_interfaces || {}
     end
 
     def editable_network_interfaces?
       true
     end
+
+    def available_resource(resource_name, options = {})
+      cache.cache("#{name}_#{resource_name}") do
+        resource = fetch_resource(resource_name, options)
+        resource.map { |h| OpenStruct.new(h) }
+      end
+    end
+
+    def available_resource_ui_select(resource_name, options = {})
+      available_resource(resource_name, options)&.map { |obj| [obj['name'], obj['id']] }
+    end
   end
 end

data/app/overrides/compute_resources_vms/tofu_indexed_networks_fields.rb

@@ -0,0 +1,7 @@
+Deface::Override.new(
+  virtual_path: 'compute_resources_vms/form/_networks',
+  name: 'tofu_indexed_networks_fields',
+  replace_contents: 'div.children_fields',
+  partial: 'foreman_opentofu/compute_resources_vms/indexed_networks_fields',
+  namespaced: true
+)

data/app/overrides/compute_resources_vms/tofu_indexed_volumes_fields.rb

@@ -0,0 +1,8 @@
+Deface::Override.new(
+  virtual_path: 'compute_resources_vms/form/_volumes',
+  name: 'tofu_indexed_volumes_fields',
+  replace_contents: 'div.children_fields',
+  partial: 'foreman_opentofu/compute_resources_vms/indexed_volumes_fields',
+  original: '7d0607bbae4c5123e89fff9968e2740a3d0eb323',
+  namespaced: true
+)

data/app/services/foreman_opentofu/app_wrapper.rb

@@ -1,6 +1,7 @@
 module ForemanOpentofu
   class AppWrapper
-    attr_reader :workdir, :planfile, :conffile
+    include HclFormat
+    attr_reader :workdir
 
     # TODO: for future versions
     #   - manage temp-work-dir; problem: no auto-remove after finished :-(
@@ -9,14 +10,33 @@ module ForemanOpentofu
     #   - use JSON-output for easier parsing
     #   - do we need locking or has the object be atomic
 
-    def initialize(workdir)
+    def initialize(workdir, opts = {})
       @workdir = workdir
-      @planfile = File.join(workdir, 'plan.bin')
-      @conffile = File.join(workdir, 'main.tf')
+      @variables = opts[:variables]
     end
 
-    def base_command
-      'tofu'
+    # rubocop:disable Style/SingleLineMethods
+    def planfile()   File.join(workdir, 'plan.bin')     end
+    def conffile()   File.join(workdir, 'main.tf')      end
+    def vardeffile() File.join(workdir, 'variables.tf') end
+
+    def base_command() 'tofu' end
+    # rubocop:enable Style/SingleLineMethods
+
+    # write variables definition file based on @variables into 'variables.tf'
+    def create_variables_file
+      File.open(vardeffile, 'w') do |f|
+        @variables.each_key do |var|
+          data = { 'type' => :string }
+          data['sensitive'] = var.to_s == 'password'
+
+          f << block_to_hcl(['variable', var], data)
+        end
+      end
+    end
+
+    def variable_params
+      @variables.map { |var, val| ['-var', "#{var}=#{val}"] }.flatten
     end
 
     def default_params
@@ -32,6 +52,8 @@ module ForemanOpentofu
     #   end
     # end
     def init(params = [], &block)
+      create_variables_file if @variables
+
       tofu_execute('init', ['-input=false'].concat(parse_params(params)), &block)
     end
 
@@ -78,18 +100,33 @@ module ForemanOpentofu
       cmd.map { |item| "'#{item}'" }.append('2>&1').join(' ')
     end
 
+    def common_envvars
+      {
+        'TF_PLUGIN_CACHE_DIR' => ForemanOpentofu::OPENTOFU_PLUGIN_CACHE_PATH,
+        'TEMPDIR' => ForemanOpentofu::OPENTOFU_TMP_PATH,
+        'TMPDIR' => ForemanOpentofu::OPENTOFU_TMP_PATH,
+        'TMP' => ForemanOpentofu::OPENTOFU_TMP_PATH,
+        'TEMP' => ForemanOpentofu::OPENTOFU_TMP_PATH,
+      }
+    end
+
+    def terraform_envvars
+      @variables.transform_keys { |variable| "TF_VAR_#{variable}" }
+    end
+
+    def envvars
+      common_envvars.merge(terraform_envvars)
+    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
+      IO.popen(envvars, commandline, 'r+', chdir: workdir) do |pipe|
+        if block_given?
+          yield pipe
+        else
+          output = pipe.read
         end
       end
       ret = $CHILD_STATUS

data/app/services/foreman_opentofu/opentofu_executer.rb

@@ -1,21 +1,35 @@
-require 'json'
-
 module ForemanOpentofu
   class OpentofuExecuter
-    def initialize(*args)
-      @compute_resource = args[0]
-      @cr_attrs = args[1] || {}
+    # 'destroy' works with TfState rather than the actual tf-file
+    # also it might not receive all the necessary data to create a valid tf-file
+    DRY_RUN_MODES = %w[destroy test].freeze
+
+    def initialize(compute_resource, args = {})
+      @compute_resource = compute_resource
+      @cr_attrs = args.to_h.with_indifferent_access
+      @resource = @cr_attrs['resource']
       @host_name = @cr_attrs['name'] || 'test'
     end
 
-    def run(mode = 'create')
-      Dir.mktmpdir('opentofu_') do |dir|
-        tofu = AppWrapper.new(dir)
+    def run(mode = '')
+      Dir.mktmpdir('opentofu_', ForemanOpentofu::OPENTOFU_TMP_PATH) do |dir|
+        # FIXME: integrate the user_data-file into AppWrapper!
+        if @cr_attrs['user_data']
+          @user_data_filename = File.join(dir, 'userdata')
+          File.open(@user_data_filename, 'w') do |f|
+            f.write(@cr_attrs['user_data'])
+          end
+        end
+        tofu = AppWrapper.new(dir, variables: {
+          username: @compute_resource.user,
+          password: @compute_resource.password,
+          endpoint: @compute_resource.url,
+        })
         @use_backend = %w[create destroy output].include?(mode)
         @token = create_token(@host_name) if @use_backend
-        tofu.main_configuration = render_template
+        tofu.main_configuration = render_template(mode)
         tofu.init
-        run_mode(tofu, mode)
+        yield(tofu)
       end
     end
 
@@ -40,45 +54,69 @@ module ForemanOpentofu
       new_token
     end
 
-    def run_mode(tofu, mode = 'new')
-      case mode
-      when 'new'
+    def run_new
+      run('new') do |tofu|
         tofu.plan
         tofu.show_plan
-      when 'test_connection'
-        tofu.plan
-      when 'create'
-        tofu.plan
+      end
+    end
+
+    def run_test_connection
+      run('test', &:plan)
+    end
+
+    def run_create
+      run('create') do |tofu|
         tofu.apply
         attrs = tofu.output('vm_attrs')
         ForemanOpentofu::TfState.find_by(name: @cr_attrs['name'])&.update(uuid: attrs['identity'])
         attrs
-      when 'output'
+      end
+    end
+
+    def run_output
+      run('output') do |tofu|
         tofu.output('vm_attrs')
-      when 'destroy'
-        tofu.destroy
-      else
-        raise "Please select one of the modes: 'new', 'test_connection', 'create' or 'destroy'"
+      end
+    end
+
+    def run_destroy
+      run('destroy', &:destroy)
+    end
+
+    def run_fetch
+      run do |tofu|
+        tofu.apply
+        tofu.output('resources')
       end
     end
 
     private
 
-    def render_template
+    def render_template(mode)
       template = provision_template
-      scope = Foreman::Renderer.get_scope(source: template)
+      variables = {
+        compute_resource: @compute_resource,
+        cr_attrs: @cr_attrs,
+        use_backend: @use_backend,
+        token: @token,
+        host_name: @host_name,
+        resource: @resource,
+        dry_run: dry_run(mode),
+        user_data_filename: @user_data_filename,
+      }
+      scope = Foreman::Renderer.get_scope(source: template, variables: variables)
       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)
-      scope.instance_variable_set(:@token, @token) if @use_backend
-      scope.instance_variable_set(:@host_name, @host_name)
       rendered_template = Foreman::Renderer::UnsafeModeRenderer.render(source, scope)
       raise ::Foreman::Exception, N_('Unable to render provisioning template') unless rendered_template
 
       rendered_template
     end
 
+    def dry_run(mode)
+      mode.empty? || DRY_RUN_MODES.include?(mode)
+    end
+
     def provision_template
       name = @compute_resource.opentofu_template.name
       template = ProvisioningTemplate.unscoped.find_by(name: name)

data/app/services/foreman_opentofu/provider_type.rb

@@ -1,30 +1,84 @@
 module ForemanOpentofu
   class ProviderType
     attr_reader :id, :name, :default_attributes
+    attr_accessor :capabilities, :disk_renderer, :nic_renderer
 
     def initialize(id)
       @id = id.to_sym
       @name = id.capitalize
+      @capabilities = [:build]
+      @provider_attrs = []
+    end
+
+    def provider_attrs=(input)
+      @provider_attrs = Array(input).map do |attr|
+        ActiveSupport::HashWithIndifferentAccess.new(attr)
+      end
+    end
+
+    # if necessary, select-parameter named 'available_images' must be specified!
+    def available_images(compute_resource)
+      attribute = find_attr_by('name', 'available_images')
+      raise NotImplementedError if attribute.nil?
+
+      query_opts = attribute['options']
+      case query_opts
+      when nil then raise NotImplementedError
+      # TODO: Check if Array really works!
+      when Array then query_opts
+      when Hash then compute_resource.available_resource(query_opts.dig('data_source', 'name'), query_opts)
+      else raise 'available_images in ProviderType config is of unknown type.'
+      end
     end
 
     # returns hash of available-attributes with attr-name as key
-    def available_attributes
+    def available_attributes(group = nil)
       raise "No available-attributes found for #{name}" unless attributes?
 
-      attributes&.index_by { |e| e['name'] }
+      attributes(group).index_by { |e| e['name'] }.with_indifferent_access
     end
 
     def attributes?
-      CR_ATTRS.key? id.to_s
+      @provider_attrs.present?
     end
 
     def attributes(group = nil)
-      return nil unless CR_ATTRS.key? id.to_s
+      return [] unless attributes?
+
+      return @provider_attrs if group.nil?
+
+      @provider_attrs.select { |e| e['group'] == group }
+    end
 
-      a = CR_ATTRS[id.to_s]
-      return a if group.nil?
+    # return Array of Hashes of all attributes that have `key` set to `value`.
+    # Optional: limited to `group`
+    def search_attr_by(key, value, group = nil)
+      attributes(group).select { |attr| attr[key] == value }
+    end
+
+    # return Hash of attribute that has `key` set to `value`.
+    # If multiple exists, first in list is returned
+    # Returns `nil` if none is found
+    # Optional: limited to `group`
+    def find_attr_by(key, value, group = nil)
+      search_attr_by(key, value, group).first
+    end
+
+    def provided_attributes
+      # TODO: maybe we need to do something more sophisticated, here.
+      #       network-based deployment needs MAC to set-up DHCP, but
+      #       on image-based deployment we usually only get IPv4/6-address
+      { mac: :mac }
+    end
+
+    def render_disk(disk, context, *args)
+      return '' unless disk_renderer
+      context.instance_exec(disk, *args, &disk_renderer)
+    end
 
-      a.select { |e| e['group'] == group }
+    def render_nic(nic, context, *args)
+      return '' unless nic_renderer
+      context.instance_exec(nic, *args, &nic_renderer)
     end
   end
 end

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

@@ -4,6 +4,9 @@
   <%= text_f f, :url, :help_block => _("127.0.0.1") %>
   <%= text_f f, :user , :help_block => _("e.g. admin") %>
   <%= password_f f, :password, :unset => unset_password? %>
+  <%= checkbox_f f, :caching_enabled, :label => _("Enable caching"),
+                 :help_inline => _("Cache slow calls to Opentofu Compute resources to speed up page rendering") %>
+
 <% end %>
 <div class="col-md-offset-2">
   <%= test_connection_button_f(f, (true)) %>

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

@@ -10,3 +10,7 @@
   <td><%= _('URL') %></td>
   <td><%= @compute_resource.url %></td>
 </tr>
+<tr>
+  <td><%= _("Caching") %></td>
+  <td><%= @compute_resource.caching_enabled ? _("Enabled") : _("Disabled") %></td>
+</tr>

data/app/views/compute_resources/tofu.json.rabl

@@ -0,0 +1 @@
+attributes :caching_enabled

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

@@ -1,13 +1,19 @@
 <% 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 } %>
+    <%= render :partial => provider_partial(compute_resource, "dynamic_attrs"), :locals => { f: f, attrs: vm_attrs, compute_resource: compute_resource } %>
   <% end %>
 <% end %>
 
+<%
+  arch ||= nil ; os ||= nil
+  images = possible_images(compute_resource, arch, os)
+%>
+
+<div id='image_selection'>
+  <%= select_f f, :image_id, images, :uuid, :name,
+               { :include_blank => (images.empty? || images.size == 1) ? false : _('Please select an image') },
+               { :disabled => images.empty?, :label => _('Image'), :label_size => "col-md-2" } %>
+</div>
+

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

@@ -1,18 +1,28 @@
 <% attrs.each do |attr|
-  label = attr.fetch('label', attr['name'].humanize) %>
+  label = attr.fetch('label', attr['name'].humanize)
+  common_options = {
+    label: _(label),
+    label_help: attr['help'],
+    required: attr['mandatory'],
+  } %>
 
-  <% case attr["type"] %>
+  <% case attr['type'] %>
   <% when 'string' %>
-    <%= text_f f, attr["name"].to_sym, label: _(label), label_help: attr['help'] %>
+    <%= text_f f, attr['name'].to_sym, common_options %>
   <% when 'bool' %>
-    <%= checkbox_f f, attr["name"].to_sym, label: _(label), label_help: attr['help'] %>
+    <%= checkbox_f f, attr['name'].to_sym, common_options %>
   <% when 'number' %>
-    <%= counter_f f, attr["name"].to_sym, label: _(label), label_help: attr['help'] %>
+    <%= counter_f f, attr['name'].to_sym, common_options %>
   <% 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'] %>
+      <% if attr['options'].is_a?(Hash) && attr['options'].key?('data_source') -%>
+        <%= selectable_f f, attr['name'].to_sym, compute_resource.available_resource_ui_select(attr.dig('options', 'data_source', 'name'), attr.dig('options')), { :include_blank => !attr['mandatory'] }, common_options %>
+      <% else -%>
+        <%= select_f f, attr['name'].to_sym, attr.fetch('options', []), :to_s, :to_s, { :include_blank => !attr['mandatory'] }, common_options %>
+        <%end -%>
     <% else  %>
-      <%= select_f f, attr["name"].to_sym, (options || []), :id, :name, { :include_blank => true }, label: _(label), label_help: attr['help'] %>
+      <% #FIXME: what to do with this? %>
+      <%= select_f f, attr['name'].to_sym, (options || []), :id, :name, { :include_blank => true }, common_options %>
     <% end %>
   <% end %>
 <% end %>

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

@@ -1,5 +1 @@
-<% 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 %>
+<%= render :partial => provider_partial(compute_resource, "dynamic_attrs"), :locals => { f: f, attrs: compute_resource.tofu_provider.attributes('nic'), compute_resource: compute_resource } %>

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

@@ -0,0 +1,2 @@
+<%= render :partial => provider_partial(compute_resource, "dynamic_attrs"), :locals => { f: f, attrs: compute_resource.tofu_provider.attributes('disk'), compute_resource: compute_resource } %>
+

data/app/views/foreman_opentofu/compute_resources_vms/_indexed_networks_fields.html.erb

@@ -0,0 +1,47 @@
+<% if compute_resource.is_a?(ForemanOpentofu::Tofu) %>
+  <div class="<%= compute_resource.interfaces_attrs_name %>_fields_template form_template" style="display: none;">
+    <%= fields_for "#{f.object_name}[#{compute_resource.interfaces_attrs_name}][new_#{compute_resource.interfaces_attrs_name}]", compute_resource.new_interface do |i| %>
+      <%= render :partial => provider_partial(compute_resource, 'network'),
+                 :locals => { :f => i, :compute_resource => compute_resource, :new_host => new_host, :new_vm => new_vm, :remove_title => _('remove network interface'), :selected_cluster => selected_cluster },
+                 :layout => 'compute_resources_vms/form/deletable_layout' %>
+    <% end %>
+  </div>
+
+  <%= field_set_tag _("Network interfaces"), :id => "network_interfaces" do %>
+    <% if compute_resource.editable_network_interfaces? %>
+      <%= render :partial => 'foreman_opentofu/compute_resources_vms/form/tofu/interfaces_fields',
+                 :locals => { :f => f, :compute_resource => compute_resource, :new_host => new_host, :new_vm => new_vm, :item_layout => item_layout, :selected_cluster => selected_cluster } %>
+
+      <% if new_vm %>
+        <%= add_child_link '+ ' + _("Add Interface"), compute_resource.interfaces_attrs_name, { :class => "info", :title => _('add new network interface') } %>
+      <% end %>
+    <% else %>
+      <div class="col-md-12">
+        <%= _('No networks found.') %>
+      </div>
+    <% end %>
+  <% end %>
+<% else %>
+  <%= new_child_fields_template(f, compute_resource.interfaces_attrs_name, {
+      :object => compute_resource.new_interface,
+      :partial => provider_partial(compute_resource, 'network'),
+      :form_builder_attrs => { :compute_resource => compute_resource, :new_host => new_host, :new_vm => new_vm, :remove_title => _('remove network interface') },
+      :layout => 'compute_resources_vms/form/deletable_layout' }) %>
+
+  <%= field_set_tag _("Network interfaces"), :id => "network_interfaces" do %>
+    <% if compute_resource.editable_network_interfaces? %>
+      <%= f.fields_for compute_resource.interfaces_attrs_name do |i| %>
+        <%= render :partial => provider_partial(compute_resource, 'network'),
+            :locals => { :f => i, :compute_resource => compute_resource, :new_host => new_host, :new_vm => new_vm, :remove_title => _('remove network interface'), :selected_cluster => selected_cluster },
+            :layout => 'compute_resources_vms/form/deletable_layout' %>
+      <% end %>
+      <% if new_vm %>
+        <%= add_child_link '+ ' + _("Add Interface"), compute_resource.interfaces_attrs_name, { :class => "info", :title => _('add new network interface') } %>
+      <% end %>
+    <% else %>
+      <div class="col-md-12">
+        <%= _('No networks found.') %>
+      </div>
+    <% end %>
+  <% end %>
+<% end %>

data/app/views/foreman_opentofu/compute_resources_vms/_indexed_volumes_fields.html.erb

@@ -0,0 +1,30 @@
+<% if compute_resource.is_a?(ForemanOpentofu::Tofu) %>
+  <div class="volumes_fields_template form_template" style="display: none;">
+    <%= fields_for "#{f.object_name}[volumes][new_volumes]", volume do |i| %>
+      <%= render :partial => provider_partial(compute_resource, 'volume'),
+                 :locals => { :f => i, :compute_resource => compute_resource, :new_host => new_vm, :new_vm => new_vm, :remove_title => _('remove storage volume') },
+                 :layout => "compute_resources_vms/form/#{item_layout}_layout" %>
+    <% end %>
+  </div>
+
+  <%= render :partial => 'foreman_opentofu/compute_resources_vms/form/tofu/volumes_fields',
+             :locals => { :f => f, :compute_resource => compute_resource, :new_host => new_vm, :new_vm => new_vm, :item_layout => item_layout } %>
+
+  <% if new_vm %>
+    <%= add_child_link '+ ' + _("Add Volume"), :volumes, { :class => "info", :title => _('add new storage volume') } %>
+  <% end %>
+<% else %>
+  <%= new_child_fields_template(f, :volumes, {
+      :object  => volume,
+      :partial => provider_partial(compute_resource, 'volume'),
+      :form_builder_attrs => { :compute_resource => compute_resource, :new_host => new_vm, :new_vm => new_vm, :remove_title => _('remove storage volume') },
+      :layout => "compute_resources_vms/form/#{item_layout}_layout" }) %>
+
+  <%= f.fields_for :volumes do |i| %>
+    <%= render :partial => provider_partial(compute_resource, 'volume'), :locals => { :f => i, :compute_resource => compute_resource, :new_host => new_vm, :new_vm => new_vm, :remove_title => _('remove storage volume') }, :layout => "compute_resources_vms/form/#{item_layout}_layout" %>
+  <% end %>
+
+  <% if new_vm %>
+    <%= add_child_link '+ ' + _("Add Volume"), :volumes, { :class => "info", :title => _('add new storage volume') } %>
+  <% end %>
+<% end %>

data/app/views/foreman_opentofu/compute_resources_vms/form/tofu/_interfaces_fields.html.erb

@@ -0,0 +1,12 @@
+<%
+  association = compute_resource.interfaces_attrs_name
+  interfaces = Array.wrap(f.object.public_send(association))
+  interfaces = [compute_resource.new_interface].compact if interfaces.empty?
+%>
+<% interfaces.each_with_index do |interface_obj, idx| %>
+  <%= fields_for "#{f.object_name}[#{association}][#{idx}]", interface_obj do |i| %>
+    <%= render :partial => provider_partial(compute_resource, 'network'),
+               :locals => { :f => i, :compute_resource => compute_resource, :new_host => new_host, :new_vm => new_vm, :remove_title => _('remove network interface'), :selected_cluster => selected_cluster },
+               :layout => "compute_resources_vms/form/#{item_layout}_layout" %>
+  <% end %>
+<% end %>

data/app/views/foreman_opentofu/compute_resources_vms/form/tofu/_volumes_fields.html.erb

@@ -0,0 +1,11 @@
+<%
+  volumes = Array.wrap(f.object.volumes)
+  volumes = [compute_resource.new_volume].compact if volumes.empty?
+%>
+<% volumes.each_with_index do |volume_obj, idx| %>
+  <%= fields_for "#{f.object_name}[volumes][#{idx}]", volume_obj do |i| %>
+    <%= render :partial => provider_partial(compute_resource, 'volume'),
+               :locals => { :f => i, :compute_resource => compute_resource, :new_host => new_host, :new_vm => new_vm, :remove_title => _('remove storage volume') },
+               :layout => "compute_resources_vms/form/#{item_layout}_layout" %>
+  <% end %>
+<% end %>

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

@@ -0,0 +1,4 @@
+<%= text_f f, :username, :value => @image.username || "root", :help_inline => _("The user that is used to ssh into the instance, normally cloud-user, ec2-user, ubuntu, root etc") %>
+<%= checkbox_f f, :user_data, :help_inline => _("Does this image support user data input (e.g. via cloud-init)?") %>
+<%= password_f f, :password, :help_inline => _("Password to authenticate with - used for SSH finish step.") %>
+<%= image_field(f, :label => _("Image ID"), :help_inline => _("ID of the Image on the Hypervisor")) %>