MiqProvisionTask based workspace provision

app/models/manageiq/providers/terraform_enterprise/automation_manager.rb

@@ -16,7 +16,7 @@ def self.description
   end
 
   def self.catalog_types
-    {"generic_terraform_enterprise" => N_("Terraform Enterprise Workspace")}
+    {"terraform_enterprise" => N_("Terraform Enterprise Workspace")}
   end
 
   def self.params_for_create

app/models/manageiq/providers/terraform_enterprise/automation_manager/provision_workflow.rb

@@ -5,6 +5,8 @@ def dialog_name_from_automate(message = 'get_dialog_name', extra_attrs = {})
   end
 
   def allowed_configuration_scripts(*args)
-    ManageIQ::Providers::TerraformEnterprise::AutomationManager::ConfigurationScript.all
+    ManageIQ::Providers::TerraformEnterprise::AutomationManager::ConfigurationScript.all.map do |cs|
+      build_ci_hash_struct(cs, %w[name description])
+    end
   end
 end

app/models/service_template_terraform_enterprise.rb

@@ -1,70 +1,31 @@
 class ServiceTemplateTerraformEnterprise < ServiceTemplate
-  include ServiceConfigurationMixin
   include ServiceTemplateAutomationMixin
 
-  alias terraform_workspace configuration_script
-  alias terraform_workspace= configuration_script=
-
-  def self.default_provisioning_entry_point(_service_type)
-    '/AutomationManagement/TerraformEnterprise/Service/Provisioning/StateMachines/Provision/CatalogItemInitialization'
-  end
-
-  def self.default_reconfiguration_entry_point
-    nil
-  end
-
-  def self.default_retirement_entry_point
-    nil
-  end
-
-  def self.create_catalog_item(options, _auth_user = nil)
+  def self.create_catalog_item(options, auth_user = nil)
     transaction do
       create_from_options(options).tap do |service_template|
-        config_info = validate_config_info(options)
-
-        service_template.terraform_workspace = if config_info[:configuration_script_id]
-                                                 ConfigurationScript.find(config_info[:configuration_script_id])
-                                               else
-                                                 config_info[:configuration]
-                                               end
-
-        service_template.create_resource_actions(config_info)
+        config_info = options[:config_info].except(:provision, :retirement, :reconfigure)
+        validate_config_info!(config_info)
+
+        wf_class = ManageIQ::Providers::TerraformEnterprise::AutomationManager::ProvisionWorkflow
+        wf       = wf_class.new(config_info, auth_user)
+        request  = wf.make_request(nil, config_info)
+        service_template.add_resource(request)
+        service_template.create_resource_actions(options[:config_info])
       end
     end
   end
 
-  def create_subtasks(_parent_service_task, _parent_service)
-    # no sub task is needed for this service
-    []
-  end
-
-  def my_zone
-    configuration_script.manager.try(:my_zone)
-  end
-
-  def self.validate_config_info(options)
-    config_info = options[:config_info] || {}
-    config_info[:provision][:fqname] ||= default_provisioning_entry_point(SERVICE_TYPE_ATOMIC) if config_info.key?(:provision)
-
-    raise _("Must provide a configuration_script_id") if config_info[:configuration_script_id].nil?
-
-    config_info
+  def self.validate_config_info!(config_info)
+    raise _("Must provide a src_configuration_script_id") if config_info[:src_configuration_script_id].nil?
   end
 
   private
 
-  def update_service_resources(config_info, _auth_user = nil)
-    return if !config_info.key?(:configuration_script_id) || config_info[:configuration_script_id] == configuration_script&.id
-
-    service_resources.find_by(:resource_type => 'ConfigurationScriptBase').destroy
-    self.configuration_script = ConfigurationScriptBase.find(config_info[:configuration_script_id])
-  end
-
   def validate_update_config_info(options)
-    super
+    config_info = super
 
-    return unless options.key?(:config_info)
-
-    self.class.validate_config_info(options)
+    self.class.validate_config_info!(config_info)
+    config_info
   end
 end

spec/models/service_template_terraform_enterprise_spec.rb

@@ -1,8 +1,9 @@
 RSpec.describe ServiceTemplateTerraformEnterprise do
-  let(:terraform_enterprise)       { FactoryBot.create(:ems_terraform_enterprise) }
-  let(:configuration_script)       { FactoryBot.create(:configuration_script_terraform_enterprise, :manager => terraform_enterprise) }
-  let(:service_dialog)             { FactoryBot.create(:dialog) }
-  let(:provision_resource_action)  { FactoryBot.create(:resource_action, :action => 'Provision') }
+  let(:user)                      { FactoryBot.create(:user_with_email_and_group) }
+  let(:terraform_enterprise)      { FactoryBot.create(:ems_terraform_enterprise) }
+  let(:configuration_script)      { FactoryBot.create(:configuration_script_terraform_enterprise, :manager => terraform_enterprise) }
+  let(:service_dialog)            { FactoryBot.create(:dialog) }
+  let(:provision_resource_action) { FactoryBot.create(:resource_action, :action => 'Provision') }
   let(:catalog_item_options) do
     {
       :name         => "Terraform Enterprise",
@@ -11,37 +12,39 @@
       :display      => "false",
       :description  => "a description",
       :config_info  => {
-        :configuration_script_id => configuration_script.id,
-        :provision               => {
+        :owner_email => user.email,
+        :source_id   => configuration_script.id,
+        :provision   => {
           :fqname    => provision_resource_action.fqname,
           :dialog_id => service_dialog.id
         }
       }
     }
   end
 
+  before { MiqDialog.seed }
+
   describe ".create_catalog_item" do
     it "creates and returns a terraform enterprise catalog item" do
-      service_template = described_class.create_catalog_item(catalog_item_options)
+      service_template = described_class.create_catalog_item(catalog_item_options, user)
 
       expect(service_template.name).to eq("Terraform Enterprise")
       expect(service_template.service_resources.count).to eq(1)
       expect(service_template.dialogs.first).to eq(service_dialog)
       expect(service_template.resource_actions.pluck(:action)).to match_array(%w[Provision])
-      expect(service_template.configuration_script).to eq(configuration_script)
       expect(service_template.config_info).to eq(catalog_item_options[:config_info])
     end
 
     it "raises an exception if configuration_script_id is missing" do
-      catalog_item_options[:config_info].delete(:configuration_script_id)
+      catalog_item_options[:config_info].delete(:source_id)
 
-      expect { described_class.create_catalog_item(catalog_item_options) }
-        .to raise_error(StandardError, "Must provide a configuration_script_id")
+      expect { described_class.create_catalog_item(catalog_item_options, user) }
+        .to raise_error(StandardError, "Must provide a source_id")
     end
   end
 
   describe "#update_catalog_item" do
-    let(:service_template)         { ServiceTemplateTerraformEnterprise.create_catalog_item(catalog_item_options) }
+    let(:service_template)         { ServiceTemplateTerraformEnterprise.create_catalog_item(catalog_item_options, user) }
     let(:new_configuration_script) { FactoryBot.create(:configuration_script_terraform_enterprise, :manager => terraform_enterprise) }
 
     it "updates the service_template" do
@@ -53,7 +56,7 @@
           :display      => "false",
           :description  => "a description",
           :config_info  => {
-            :configuration_script_id => new_configuration_script.id,
+            :source_id => new_configuration_script.id,
             :provision               => {
               :fqname    => provision_resource_action.fqname,
               :dialog_id => service_dialog.id
@@ -63,8 +66,8 @@
       )
 
       expect(service_template.reload).to have_attributes(
-        :name                 => "Updated Terraform Enterprise",
-        :configuration_script => new_configuration_script
+        :name        => "Updated Terraform Enterprise",
+        :config_info => hash_including(:source_id => new_configuration_script.id)
       )
     end
   end