foreman_nutanix 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0782547a714f12943e80c4f2e4eef7eeabec0dd586ffa5c1744156014b20d3f
-  data.tar.gz: 66704a2b48bcc57bacb8a44f5a996b737ab671b0eb9923079793b92e164d2864
+  metadata.gz: 20eff365f58c477410d10f5b140961e4825738e49601442bec1740613aaf5704
+  data.tar.gz: bcefb95f0276c18905b569b187436a59a5e33276320b84238d4d6204e4ea3e6a
 SHA512:
-  metadata.gz: 8f3f940f6dd0918586e800e10d40b0ca8afad77216fffc577671e69f96518c729bafdf1e694ebf2f13d62f7a2433deb0428ec5f788f5e843c729bc71fabe4325
-  data.tar.gz: 4f42b6419740c82a050f71121f28e893dcd1e2322560db45dc435b9b157e2eeb9fad6e44377d76bb971f3f31e47f2b4b18a7ffa9e39e5c759316f91374983afc
+  metadata.gz: 461cc7ed6c08843073891195b480c8356c148fadf2d2825aacfb0c8284167967abe1e30e37ac37a93c8cb102d86dc75cbab37ab93bca3789b4707cf87f63365e
+  data.tar.gz: bfea4f00a1a9148d6568014c9904b1afaef15172fb70033f386132fe83fd438b89896c3ecc8e6139104874f961908f9f5154cf0f7263caa0a112b9e5fea9acd6

data/Rakefile

@@ -20,8 +20,6 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-APP_RAKEFILE = File.expand_path('test/dummy/Rakefile', __dir__)
-
 Bundler::GemHelper.install_tasks
 
 require 'rake/testtask'
@@ -43,7 +41,3 @@ rescue StandardError => _e
 rescue LoadError
   puts 'Rubocop not loaded.'
 end
-
-task :default do
-  Rake::Task['rubocop'].execute
-end

data/app/lib/foreman_nutanix/nutanix_adapter.rb

@@ -33,15 +33,13 @@ module ForemanNutanix
         Rails.logger.info "=== NUTANIX: ServersCollection::get called with uuid: #{uuid} ==="
 
         # Extract the actual UUID if it has a prefix
-        actual_uuid = uuid.to_s.include?(':') ? uuid.to_s.split(':').last : uuid.to_s
+        actual_uuid = ShimClient.normalize_uuid(uuid)
 
         # Fetch full VM details from shim server
-        base = ENV['NUTANIX_SHIM_SERVER_ADDR'] || 'http://localhost:8000'
-        uri = URI("#{base.chomp('/')}/api/v1/vmm/vms/#{actual_uuid}")
-        response = Net::HTTP.get_response(uri)
+        response = shim.get("/api/v1/vmm/vms/#{actual_uuid}")
 
-        if response.is_a?(Net::HTTPSuccess)
-          data = JSON.parse(response.body)
+        if response.success?
+          data = response.json
 
           total_cpus = (data['num_sockets'] || 1) * (data['num_cores_per_socket'] || 1)
           memory_gb = data['memory_size_bytes'] ? (data['memory_size_bytes'].to_f / 1024**3).round : 4
@@ -82,10 +80,7 @@ module ForemanNutanix
         Rails.logger.info "=== NUTANIX: ServersCollection::all called with opts: #{opts} ==="
 
         # Fetch VMs from shim server (now includes MAC and IP)
-        base = ENV['NUTANIX_SHIM_SERVER_ADDR'] || 'http://localhost:8000'
-        uri = URI("#{base.chomp('/')}/api/v1/vmm/list-vms")
-        response = Net::HTTP.get_response(uri)
-        data = JSON.parse(response.body)
+        data = shim.get('/api/v1/vmm/list-vms').json
 
         # Filter VMs by cluster
         filtered_data = data.select { |vm| vm['cluster_ext_id'] == @cluster }
@@ -106,6 +101,7 @@ module ForemanNutanix
             ip_addresses: vm_data['ip_addresses'] || [],
             create_time: vm_data['create_time'],
             disk_size_gb: vm_data['disk_size_bytes'].to_i / (1024**3),
+            gpus: vm_data['gpus'],
           })
           vm.instance_variable_set(:@persisted, true)
           vm
@@ -114,6 +110,14 @@ module ForemanNutanix
         Rails.logger.error "=== NUTANIX: Error fetching VMs: #{e.message} ==="
         []
       end
+
+      private
+
+      # ServersCollection holds no reference to the ComputeResource, so it builds
+      # its own client off the shim server address in the environment.
+      def shim
+        @shim ||= ShimClient.new
+      end
     end
   end
 end

data/app/models/foreman_nutanix/nutanix.rb

@@ -40,8 +40,9 @@ module ForemanNutanix
       "#{name} (#{provider_friendly_name})"
     end
 
+    # Kept public: app/views/compute_resources/show/_nutanix.html.erb renders it.
     def shim_server_url
-      ENV['NUTANIX_SHIM_SERVER_ADDR'] || 'http://localhost:8000'
+      ShimClient.default_base_url
     end
 
     def provided_attributes
@@ -56,10 +57,7 @@ module ForemanNutanix
 
     # Available clusters for selection
     def available_clusters
-      base = ENV['NUTANIX_SHIM_SERVER_ADDR'] || 'http://localhost:8000'
-      uri = URI("#{base.chomp('/')}/api/v1/clustermgmt/list-clusters")
-      response = Net::HTTP.get_response(uri)
-      data = JSON.parse(response.body)
+      data = shim.get('/api/v1/clustermgmt/list-clusters').json
 
       data.map do |cluster|
         cluster[:name] = "#{cluster['name']} (#{cluster['arch']})"
@@ -80,10 +78,7 @@ module ForemanNutanix
     # Available networks for VMs
     def available_networks
       Rails.logger.info '=== NUTANIX: Fetching available networks from shim server ==='
-      base = ENV['NUTANIX_SHIM_SERVER_ADDR'] || 'http://localhost:8000'
-      uri = URI("#{base.chomp('/')}/api/v1/networking/list-networks")
-      response = Net::HTTP.get_response(uri)
-      data = JSON.parse(response.body)
+      data = shim.get('/api/v1/networking/list-networks').json
 
       # Filter networks by the cluster associated with this compute resource
       cluster_ext_id = cluster
@@ -114,10 +109,7 @@ module ForemanNutanix
     # Available storage containers for VMs
     def available_storage_containers
       Rails.logger.info '=== NUTANIX: Fetching available storage containers from shim server ==='
-      base = ENV['NUTANIX_SHIM_SERVER_ADDR'] || 'http://localhost:8000'
-      uri = URI("#{base.chomp('/')}/api/v1/clustermgmt/list-storage-containers")
-      response = Net::HTTP.get_response(uri)
-      data = JSON.parse(response.body)
+      data = shim.get('/api/v1/clustermgmt/list-storage-containers').json
 
       # Filter storage containers by the cluster associated with this compute resource
       cluster_ext_id = cluster
@@ -143,16 +135,55 @@ module ForemanNutanix
       []
     end
 
+    # Physical GPU profiles on this cluster, as options for the VM form's single
+    # GPU select.
+    #
+    # One select can only post one value, so the option id is a composite of the
+    # three things the shim's provision call needs:
+    # "<device_id>:<vendor_name>:<gpu_type>", e.g. "7864:NVIDIA:PASSTHROUGH_GRAPHICS".
+    # NutanixCompute#save splits it back apart.
+    #
+    # A profile ext_id is deliberately NOT the value: it pins the VM to one
+    # physical card, which fails the moment that card is busy. A device_id names
+    # a GPU model, so Nutanix schedules any free matching card.
+    def available_gpus
+      Rails.logger.info '=== NUTANIX: Fetching available GPU profiles from shim server ==='
+      cluster_ext_id = cluster
+      return [] unless cluster_ext_id
+
+      data = shim.get("/api/v1/clustermgmt/clusters/#{cluster_ext_id}/gpu-profiles").json
+
+      # Passthrough only, and only profiles whose composite round-trips. See
+      # ForemanNutanix::GpuProfile.usable? - an unusable profile offered here
+      # would provision a VM with no GPU and still report success.
+      filtered_data = data.select { |profile| GpuProfile.usable?(profile) }
+      Rails.logger.info "=== NUTANIX: GPU profiles - total: #{data.count}, usable: #{filtered_data.count} ==="
+
+      filtered_data.map do |profile|
+        OpenStruct.new({
+          id: GpuProfile.build(profile),
+          ext_id: profile['ext_id'],
+          name: GpuProfile.label(profile),
+          device_id: profile['device_id'],
+          device_name: profile['device_name'],
+          vendor_name: profile['vendor_name'],
+          gpu_type: profile['gpu_type'],
+          assignable: profile['assignable'],
+          is_in_use: profile['is_in_use'],
+        })
+      end
+    rescue StandardError => e
+      Rails.logger.error "=== NUTANIX: Error fetching GPU profiles: #{e.message} ==="
+      []
+    end
+
     # Cluster resource statistics (CPU, memory, storage usage)
     def cluster_resource_stats
       Rails.logger.info '=== NUTANIX: Fetching cluster resource stats from shim server ==='
-      base = ENV['NUTANIX_SHIM_SERVER_ADDR'] || 'http://localhost:8000'
       cluster_id = cluster
       return nil unless cluster_id
 
-      uri = URI("#{base.chomp('/')}/api/v1/clustermgmt/clusters/#{cluster_id}/stats")
-      response = Net::HTTP.get_response(uri)
-      data = JSON.parse(response.body)
+      data = shim.get("/api/v1/clustermgmt/clusters/#{cluster_id}/stats").json
 
       OpenStruct.new(data)
     rescue StandardError => e
@@ -163,10 +194,7 @@ module ForemanNutanix
     # Available images
     def available_images(_opts = {})
       Rails.logger.info '=== NUTANIX: Fetching available images from shim server ==='
-      base = ENV['NUTANIX_SHIM_SERVER_ADDR'] || 'http://localhost:8000'
-      uri = URI("#{base.chomp('/')}/api/v1/vmm/list-images")
-      response = Net::HTTP.get_response(uri)
-      data = JSON.parse(response.body)
+      data = shim.get('/api/v1/vmm/list-images').json
 
       # Filter images by cluster if cluster_location_ext_ids is available
       cluster_ext_id = cluster
@@ -286,20 +314,10 @@ module ForemanNutanix
     # Start VM - called by Foreman for power on
     def start_vm(uuid)
       Rails.logger.info "=== NUTANIX: START_VM CALLED with uuid: #{uuid} ==="
-      actual_uuid = uuid.to_s.include?(':') ? uuid.to_s.split(':').last : uuid.to_s
+      actual_uuid = ShimClient.normalize_uuid(uuid)
 
-      base = shim_server_url
-      uri = URI("#{base.chomp('/')}/api/v1/vmm/vms/#{actual_uuid}/power-state")
-
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = uri.scheme == 'https'
-
-      request = Net::HTTP::Post.new(uri.path)
-      request['Content-Type'] = 'application/json'
-      request.body = { action: 'POWER_ON' }.to_json
-
-      response = http.request(request)
-      response.is_a?(Net::HTTPSuccess)
+      response = shim.post("/api/v1/vmm/vms/#{actual_uuid}/power-state", { action: 'POWER_ON' })
+      response.success?
     rescue StandardError => e
       Rails.logger.error "=== NUTANIX: START_VM ERROR: #{e.message} ==="
       raise e
@@ -308,20 +326,10 @@ module ForemanNutanix
     # Stop VM - called by Foreman for power off
     def stop_vm(uuid)
       Rails.logger.info "=== NUTANIX: STOP_VM CALLED with uuid: #{uuid} ==="
-      actual_uuid = uuid.to_s.include?(':') ? uuid.to_s.split(':').last : uuid.to_s
-
-      base = shim_server_url
-      uri = URI("#{base.chomp('/')}/api/v1/vmm/vms/#{actual_uuid}/power-state")
-
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = uri.scheme == 'https'
-
-      request = Net::HTTP::Post.new(uri.path)
-      request['Content-Type'] = 'application/json'
-      request.body = { action: 'POWER_OFF' }.to_json
+      actual_uuid = ShimClient.normalize_uuid(uuid)
 
-      response = http.request(request)
-      response.is_a?(Net::HTTPSuccess)
+      response = shim.post("/api/v1/vmm/vms/#{actual_uuid}/power-state", { action: 'POWER_OFF' })
+      response.success?
     rescue StandardError => e
       Rails.logger.error "=== NUTANIX: STOP_VM ERROR: #{e.message} ==="
       raise e
@@ -331,14 +339,12 @@ module ForemanNutanix
     def vm_power_state(vm)
       Rails.logger.info "=== NUTANIX: VM_POWER_STATE CALLED for vm: #{vm} ==="
       uuid = vm.respond_to?(:identity) ? vm.identity : vm.to_s
-      actual_uuid = uuid.to_s.include?(':') ? uuid.to_s.split(':').last : uuid.to_s
+      actual_uuid = ShimClient.normalize_uuid(uuid)
 
-      base = shim_server_url
-      uri = URI("#{base.chomp('/')}/api/v1/vmm/vms/#{actual_uuid}/power-state")
-      response = Net::HTTP.get_response(uri)
+      response = shim.get("/api/v1/vmm/vms/#{actual_uuid}/power-state")
 
-      if response.is_a?(Net::HTTPSuccess)
-        data = JSON.parse(response.body)
+      if response.success?
+        data = response.json
         state = data['power_state']
         Rails.logger.info "=== NUTANIX: VM_POWER_STATE returning: #{state} ==="
         # Return hash that Foreman expects
@@ -375,19 +381,12 @@ module ForemanNutanix
       return true if uuid.nil? || uuid.to_s.strip.empty?
 
       # Extract the actual UUID if it has a prefix
-      actual_uuid = uuid.to_s.include?(':') ? uuid.to_s.split(':').last : uuid.to_s
+      actual_uuid = ShimClient.normalize_uuid(uuid)
 
       # Call the shim server to delete the VM
-      base = shim_server_url
-      uri = URI("#{base.chomp('/')}/api/v1/vmm/vms/#{actual_uuid}")
+      response = shim.delete("/api/v1/vmm/vms/#{actual_uuid}")
 
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = uri.scheme == 'https'
-
-      request = Net::HTTP::Delete.new(uri.path)
-      response = http.request(request)
-
-      if response.is_a?(Net::HTTPNoContent) || response.is_a?(Net::HTTPSuccess)
+      if response.no_content? || response.success?
         Rails.logger.info "=== NUTANIX: VM #{actual_uuid} deleted successfully ==="
         true
       else
@@ -455,6 +454,13 @@ module ForemanNutanix
 
     private
 
+    # "NVIDIA Tesla T4 (2 assignable)". Every part is optional in the shim's
+    # payload, so degrade instead of rendering a blank option.
+
+    def shim
+      @shim ||= ShimClient.new(shim_server_url)
+    end
+
     def client
       Rails.logger.info "=== NUTANIX: Creating client for cluster #{cluster} ==="
       @client ||= NutanixAdapter.new(cluster)

data/app/models/foreman_nutanix/nutanix_compute.rb

@@ -7,7 +7,7 @@ module ForemanNutanix
       :storage_container_ext_id, :num_sockets, :num_cores_per_socket,
       :disk_size_bytes, :description, :network_id, :storage_container,
       :disk_size_gb, :mac_address, :vm_ip_addresses, :create_time,
-      :boot_method, :secure_boot, :gpus
+      :boot_method, :secure_boot, :gpus, :gpu, :gpu_count
 
     def initialize(cluster = nil, args = {})
       Rails.logger.info "=== NUTANIX: NutanixCompute::initialize cluster=#{cluster} args=#{args} ==="
@@ -46,8 +46,17 @@ module ForemanNutanix
       @boot_method = args[:boot_method]
       @secure_boot = args[:secure_boot]
 
-      # GPUs
-      @gpus = args[:gpus]
+      # GPUs. Defaults to [] rather than nil: the shim's /list-vms response
+      # carries no gpus field, so VMs built by ServersCollection#all never
+      # receive one, and the index view calls #gpus.empty? on every row.
+      @gpus = args[:gpus] || []
+
+      # GPU passthrough selection. `gpu` is the composite the form's single
+      # select carries: "<device_id>:<vendor_name>:<gpu_type>". Both stay nil
+      # when nothing was selected, which is what keeps #save's payload
+      # byte-identical to a GPU-less provision.
+      @gpu = args[:gpu]
+      @gpu_count = args[:gpu_count]
     end
 
     # Required by Foreman - indicates if VM exists
@@ -96,23 +105,17 @@ module ForemanNutanix
         boot_method: @boot_method,
       }
 
+      # Adds nothing at all unless a GPU was actually selected, so a GPU-less
+      # provision posts exactly the request it always did.
+      provision_request.merge!(gpu_provision_fields)
+
       Rails.logger.info "=== NUTANIX: Provisioning VM with request: #{provision_request} ==="
 
       # Call the shim server to provision the VM
-      base = ENV['NUTANIX_SHIM_SERVER_ADDR'] || 'http://localhost:8000'
-      uri = URI("#{base.chomp('/')}/api/v1/vmm/provision-vm")
-
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = uri.scheme == 'https'
-
-      request = Net::HTTP::Post.new(uri.path)
-      request['Content-Type'] = 'application/json'
-      request.body = provision_request.to_json
+      response = shim.post('/api/v1/vmm/provision-vm', provision_request)
 
-      response = http.request(request)
-
-      if response.is_a?(Net::HTTPSuccess)
-        result = JSON.parse(response.body)
+      if response.success?
+        result = response.json
         Rails.logger.info "=== NUTANIX: VM provisioned successfully: #{result} ==="
 
         # Update identity with the real ext_id from Nutanix
@@ -176,22 +179,12 @@ module ForemanNutanix
       return false unless persisted?
 
       # Extract actual UUID (handle ZXJnb24=:uuid format)
-      actual_uuid = @identity.to_s.include?(':') ? @identity.to_s.split(':').last : @identity.to_s
+      actual_uuid = ShimClient.normalize_uuid(@identity)
 
       # Call the shim server to power on the VM
-      base = ENV['NUTANIX_SHIM_SERVER_ADDR'] || 'http://localhost:8000'
-      uri = URI("#{base.chomp('/')}/api/v1/vmm/vms/#{actual_uuid}/power-state")
-
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = uri.scheme == 'https'
-
-      request = Net::HTTP::Post.new(uri.path)
-      request['Content-Type'] = 'application/json'
-      request.body = { action: 'POWER_ON' }.to_json
+      response = shim.post("/api/v1/vmm/vms/#{actual_uuid}/power-state", { action: 'POWER_ON' })
 
-      response = http.request(request)
-
-      if response.is_a?(Net::HTTPSuccess)
+      if response.success?
         Rails.logger.info "=== NUTANIX: VM #{actual_uuid} powered on successfully ==="
         @power_state = 'ON'
         true
@@ -211,22 +204,12 @@ module ForemanNutanix
       return false unless persisted?
 
       # Extract actual UUID (handle ZXJnb24=:uuid format)
-      actual_uuid = @identity.to_s.include?(':') ? @identity.to_s.split(':').last : @identity.to_s
+      actual_uuid = ShimClient.normalize_uuid(@identity)
 
       # Call the shim server to power off the VM
-      base = ENV['NUTANIX_SHIM_SERVER_ADDR'] || 'http://localhost:8000'
-      uri = URI("#{base.chomp('/')}/api/v1/vmm/vms/#{actual_uuid}/power-state")
-
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = uri.scheme == 'https'
-
-      request = Net::HTTP::Post.new(uri.path)
-      request['Content-Type'] = 'application/json'
-      request.body = { action: 'POWER_OFF' }.to_json
+      response = shim.post("/api/v1/vmm/vms/#{actual_uuid}/power-state", { action: 'POWER_OFF' })
 
-      response = http.request(request)
-
-      if response.is_a?(Net::HTTPSuccess)
+      if response.success?
         Rails.logger.info "=== NUTANIX: VM #{actual_uuid} powered off successfully ==="
         @power_state = 'OFF'
         true
@@ -240,6 +223,20 @@ module ForemanNutanix
       raise e
     end
 
+    # Human-readable GPU labels for the views, e.g. "NVIDIA Tesla T4".
+    # The shim returns each GPU as a hash; a shim older than 0.1.5 omits the
+    # field on /list-vms entirely, which #initialize turns into [].
+    def gpu_labels
+      @gpus.map do |gpu|
+        next gpu.to_s unless gpu.is_a?(Hash)
+
+        name = gpu['name']
+        name = gpu['device_id'] if blank_gpu_field?(name)
+        label = [gpu['vendor'], name].reject { |part| blank_gpu_field?(part) }.join(' ')
+        label.empty? ? 'GPU' : label
+      end
+    end
+
     # Required by Foreman - CPU count
     def cpu
       Rails.logger.info '=== NUTANIX: NutanixCompute::cpu called ==='
@@ -377,11 +374,62 @@ module ForemanNutanix
       yield if block_given?
     end
 
+    # Deliberately not ActiveSupport's #blank?: this class is loaded without
+    # Rails in test/nutanix_compute_test.rb.
+    def blank_gpu_field?(value)
+      value.nil? || value.to_s.strip.empty?
+    end
+    private :blank_gpu_field?
+
     # Required by Foreman - destroy VM
     def destroy
       Rails.logger.info '=== NUTANIX: NutanixCompute::destroy called ==='
       @persisted = false
       true
     end
+
+    private
+
+    # The form's GPU select carries a single composite value,
+    # "<device_id>:<vendor_name>:<gpu_type>" (e.g. "7864:NVIDIA:PASSTHROUGH_GRAPHICS"),
+    # because one select cannot post three fields. Split it back apart here.
+    #
+    # Returns {} unless all three parts are present: a half-parsed composite
+    # must contribute nothing rather than provision a VM against a partially
+    # specified GPU. {} is also the no-GPU-selected case, which is what keeps
+    # the provision request byte-identical to a pre-GPU one.
+    def gpu_provision_fields
+      # Nothing selected is the common case and means exactly that.
+      return {} if GpuProfile.blank?(@gpu)
+
+      # Selected but unparseable is different: the user asked for a GPU. Dropping
+      # it here would build a GPU-less VM and report the build as successful, so
+      # fail the way a missing network or storage container does.
+      parts = GpuProfile.parse(@gpu)
+      if parts.nil?
+        raise StandardError, "Malformed GPU selection #{@gpu.inspect}; expected " \
+                             "'<device_id>:<vendor>:<gpu_type>'"
+      end
+
+      device_id, vendor, mode = parts
+
+      # The count field is hidden until a GPU is picked, so it routinely arrives
+      # nil or empty; one GPU is what selecting a GPU means.
+      count = @gpu_count.to_i
+      count = 1 if count < 1
+
+      {
+        gpu_device_id: device_id.to_i,
+        gpu_vendor: vendor,
+        gpu_mode: mode,
+        gpu_count: count,
+      }
+    end
+
+    # NutanixCompute holds no reference to the ComputeResource, so it builds its
+    # own client off the shim server address in the environment.
+    def shim
+      @shim ||= ShimClient.new
+    end
   end
 end

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

@@ -66,6 +66,32 @@ compute_resource.available_storage_containers,
   max: 10_000,
 } %>
 
+<%# One select for three shim fields: the option value is the composite
+#    "<device_id>:<vendor_name>:<gpu_type>". NutanixCompute#save splits it.
+#    Passthrough only - available_gpus filters vGPU profiles out. %>
+<%= select_f f,
+:gpu,
+compute_resource.available_gpus,
+:id,
+:name,
+{ include_blank: _("No GPU"), selected: f.object.try(:gpu) },
+{
+  label: _("GPU"),
+  help_inline: _("Passthrough GPU to attach when the VM is created"),
+  id: "gpu-select",
+} %>
+
+<div id="gpu-options" class="hidden">
+  <%= counter_f f,
+  :gpu_count,
+  {
+    label: _("GPU Count"),
+    help_inline: _("How many of the selected GPU to attach"),
+    min: 1,
+    max: 8,
+  } %>
+</div>
+
 <%# `checked:` must reflect the saved value, else the box always renders
 #    checked and the compute profile's "off" never survives a page render.
 #    f.object is compute_resource.new_vm(vm_attrs); NutanixCompute has no :start
@@ -106,11 +132,20 @@ compute_resource.available_boot_methods,
 
 <script>
   var $bootMethod = $('#boot-method-select');
+  var $gpu = $('#gpu-select');
 
   function toggleUefiOptions() {
     $('#uefi-options').toggleClass('hidden', $bootMethod.val() !== 'uefi');
   }
 
+  // Same pattern as above: the count only means anything once a GPU is picked,
+  // and the blank "No GPU" option posts an empty value.
+  function toggleGpuOptions() {
+    $('#gpu-options').toggleClass('hidden', !$gpu.val());
+  }
+
   toggleUefiOptions();
+  toggleGpuOptions();
   $bootMethod.on('change', toggleUefiOptions);
+  $gpu.on('change', toggleGpuOptions);
 </script>

data/app/views/compute_resources_vms/show/_nutanix.html.erb

@@ -53,7 +53,8 @@
     </tr>
     <tr>
       <td><%= _("GPUs") %></td>
-      <td><%= @vm.gpus %></td>
+      <% gpu_labels = @vm.gpu_labels %>
+      <td><%= gpu_labels.any? ? gpu_labels.join(", ") : _("None") %></td>
     </tr>
   </tbody>
 </table>

data/lib/foreman_nutanix/gpu_profile.rb

@@ -0,0 +1,54 @@
+module ForemanNutanix
+  # The compute profile form is a single select, so a GPU choice is stored as one
+  # composite string: "<device_id>:<vendor_name>:<gpu_type>". This module owns that
+  # format at both ends - Nutanix#available_gpus builds it, NutanixCompute#save
+  # parses it - so the two can never disagree about it.
+  #
+  # Plain Ruby, no Rails: loaded directly by the standalone tests. See test/README.md.
+  module GpuProfile
+    SEPARATOR = ':'.freeze
+    PARTS = %w[device_id vendor_name gpu_type].freeze
+
+    module_function
+
+    def blank?(value)
+      value.nil? || value.to_s.strip.empty?
+    end
+
+    # Only offer a profile that can survive the round trip: passthrough (the shim
+    # rejects VIRTUAL), and every composite part present. A profile missing one
+    # part builds a composite that #parse rejects, which would provision a VM with
+    # no GPU while reporting success.
+    def usable?(profile)
+      return false unless profile[PARTS.last].to_s.start_with?('PASSTHROUGH')
+
+      PARTS.none? { |part| blank?(profile[part]) }
+    end
+
+    def build(profile)
+      PARTS.map { |part| profile[part] }.join(SEPARATOR)
+    end
+
+    # [device_id, vendor, mode], or nil if this is not a usable composite.
+    # Caller distinguishes "nothing selected" from "malformed" by checking blank?
+    # first - the two mean very different things at provision time.
+    def parse(composite)
+      return nil if blank?(composite)
+
+      parts = composite.to_s.split(SEPARATOR, PARTS.length)
+      return nil unless parts.length == PARTS.length
+      return nil if parts.any? { |part| blank?(part) }
+
+      parts
+    end
+
+    def label(profile)
+      name = [profile['vendor_name'], profile['device_name']]
+             .reject { |part| blank?(part) }
+             .join(' ')
+      name = "GPU #{profile['device_id']}" if name.empty?
+      assignable = profile['assignable']
+      assignable.nil? ? name : "#{name} (#{assignable} assignable)"
+    end
+  end
+end