Add IBMi Software License field to instance data source and resource

ibm/service/power/data_source_ibm_pi_instance.go

@@ -195,6 +195,26 @@ func DataSourceIBMPIInstance() *schema.Resource {
 				Type:     schema.TypeString,
 				Computed: true,
 			},
+			PIInstanceIbmiCSS: {
+				Type:        schema.TypeBool,
+				Computed:    true,
+				Description: "IBMi Cloud Storage Solution",
+			},
+			PIInstanceIbmiPHA: {
+				Type:        schema.TypeBool,
+				Computed:    true,
+				Description: "IBMi Power High Availability",
+			},
+			PIInstanceIbmiRDS: {
+				Type:        schema.TypeBool,
+				Computed:    true,
+				Description: "IBMi Rational Dev Studio",
+			},
+			PIInstanceIbmiRDSUsers: {
+				Type:        schema.TypeInt,
+				Computed:    true,
+				Description: "IBMi Rational Dev Studio Number of User Licenses",
+			},
 		},
 	}
 }
@@ -262,5 +282,16 @@ func dataSourceIBMPIInstancesRead(ctx context.Context, d *schema.ResourceData, m
 		d.Set("health_status", powervmdata.Health.Status)
 	}
 
+	if powervmdata.SoftwareLicenses != nil {
+		d.Set(PIInstanceIbmiCSS, powervmdata.SoftwareLicenses.IbmiCSS)
+		d.Set(PIInstanceIbmiPHA, powervmdata.SoftwareLicenses.IbmiPHA)
+		d.Set(PIInstanceIbmiRDS, powervmdata.SoftwareLicenses.IbmiRDS)
+		if *powervmdata.SoftwareLicenses.IbmiRDS {
+			d.Set(PIInstanceIbmiRDSUsers, powervmdata.SoftwareLicenses.IbmiRDSUsers)
+		} else {
+			d.Set(PIInstanceIbmiRDSUsers, 0)
+		}
+	}
+
 	return nil
 }

ibm/service/power/ibm_pi_constants.go

@@ -46,6 +46,12 @@ const (
 	Arg_PVMInstanceId           = "pi_instance_id"
 	Arg_PVMInstanceActionType   = "pi_action"
 	Arg_PVMInstanceHealthStatus = "pi_health_status"
+	PIInstanceSoftwareLicenses  = "pi_software_licenses"
+	PIInstanceIbmiCSS           = "pi_ibmi_css"
+	PIInstanceIbmiPHA           = "pi_ibmi_pha"
+	PIInstanceIbmiRDS           = "pi_ibmi_rds"
+	PIInstanceIbmiRDSUsers      = "pi_ibmi_rds_users"
+	OS_IBMI                     = "ibmi"
 
 	Attr_Status       = "status"
 	Attr_Progress     = "progress"

ibm/service/power/resource_ibm_pi_instance.go

@@ -352,6 +352,28 @@ func ResourceIBMPIInstance() *schema.Resource {
 				Computed:    true,
 				Description: "Minimum Virtual Cores Assigned to the PVMInstance",
 			},
+			PIInstanceIbmiCSS: {
+				Type:        schema.TypeBool,
+				Optional:    true,
+				Description: "IBMi Cloud Storage Solution",
+			},
+			PIInstanceIbmiPHA: {
+				Type:        schema.TypeBool,
+				Optional:    true,
+				Description: "IBMi Power High Availability",
+			},
+			PIInstanceIbmiRDS: {
+				Type:        schema.TypeBool,
+				Optional:    false,
+				Required:    false,
+				Computed:    true,
+				Description: "IBMi Rational Dev Studio",
+			},
+			PIInstanceIbmiRDSUsers: {
+				Type:        schema.TypeInt,
+				Optional:    true,
+				Description: "IBMi Rational Dev Studio Number of User Licenses",
+			},
 		},
 	}
 }
@@ -496,6 +518,16 @@ func resourceIBMPIInstanceRead(ctx context.Context, d *schema.ResourceData, meta
 	}
 	d.Set(helpers.PIInstanceLicenseRepositoryCapacity, powervmdata.LicenseRepositoryCapacity)
 	d.Set(PIInstanceDeploymentType, powervmdata.DeploymentType)
+	if powervmdata.SoftwareLicenses != nil {
+		d.Set(PIInstanceIbmiCSS, powervmdata.SoftwareLicenses.IbmiCSS)
+		d.Set(PIInstanceIbmiPHA, powervmdata.SoftwareLicenses.IbmiPHA)
+		d.Set(PIInstanceIbmiRDS, powervmdata.SoftwareLicenses.IbmiRDS)
+		if *powervmdata.SoftwareLicenses.IbmiRDS {
+			d.Set(PIInstanceIbmiRDSUsers, powervmdata.SoftwareLicenses.IbmiRDSUsers)
+		} else {
+			d.Set(PIInstanceIbmiRDSUsers, 0)
+		}
+	}
 	return nil
 }
 
@@ -546,7 +578,6 @@ func resourceIBMPIInstanceUpdate(ctx context.Context, d *schema.ResourceData, me
 	}
 
 	if d.HasChange(helpers.PIInstanceProcType) {
-
 		// Stop the lpar
 		if d.Get("status") == "SHUTOFF" {
 			log.Printf("the lpar is in the shutoff state. Nothing to do . Moving on ")
@@ -599,7 +630,6 @@ func resourceIBMPIInstanceUpdate(ctx context.Context, d *schema.ResourceData, me
 
 	// Start of the change for Memory and Processors
 	if d.HasChange(helpers.PIInstanceMemory) || d.HasChange(helpers.PIInstanceProcessors) || d.HasChange("pi_migratable") {
-
 		maxMemLpar := d.Get("max_memory").(float64)
 		maxCPULpar := d.Get("max_processors").(float64)
 		//log.Printf("the required memory is set to [%d] and current max memory is set to  [%d] ", int(mem), int(maxMemLpar))
@@ -659,7 +689,6 @@ func resourceIBMPIInstanceUpdate(ctx context.Context, d *schema.ResourceData, me
 	// License repository capacity will be updated only if service instance is a vtl instance
 	// might need to check if lrc was set
 	if d.HasChange(helpers.PIInstanceLicenseRepositoryCapacity) {
-
 		lrc := d.Get(helpers.PIInstanceLicenseRepositoryCapacity).(int64)
 		body := &models.PVMInstanceUpdate{
 			LicenseRepositoryCapacity: lrc,
@@ -720,7 +749,6 @@ func resourceIBMPIInstanceUpdate(ctx context.Context, d *schema.ResourceData, me
 	}
 
 	if d.HasChange(helpers.PIPlacementGroupID) {
-
 		pgClient := st.NewIBMPIPlacementGroupClient(ctx, sess, cloudInstanceID)
 
 		oldRaw, newRaw := d.GetChange(helpers.PIPlacementGroupID)
@@ -754,9 +782,38 @@ func resourceIBMPIInstanceUpdate(ctx context.Context, d *schema.ResourceData, me
 			}
 		}
 	}
+	if d.HasChanges(PIInstanceIbmiCSS, PIInstanceIbmiPHA, PIInstanceIbmiRDSUsers) {
+		if d.Get("status") == "ACTIVE" {
+			log.Printf("the lpar is in the Active state, continuing with update")
+		} else {
+			_, err = isWaitForPIInstanceAvailable(ctx, client, instanceID, "OK")
+			if err != nil {
+				return diag.FromErr(err)
+			}
+		}
 
-	return resourceIBMPIInstanceRead(ctx, d, meta)
+		sl := &models.SoftwareLicenses{}
+		sl.IbmiCSS = flex.PtrToBool(d.Get(PIInstanceIbmiCSS).(bool))
+		sl.IbmiPHA = flex.PtrToBool(d.Get(PIInstanceIbmiPHA).(bool))
+		ibmrdsUsers := d.Get(PIInstanceIbmiRDSUsers).(int)
+		if ibmrdsUsers < 0 {
+			return diag.Errorf("request with IBMi Rational Dev Studio property requires IBMi Rational Dev Studio number of users")
+		}
+		sl.IbmiRDS = flex.PtrToBool(ibmrdsUsers > 0)
+		sl.IbmiRDSUsers = int64(ibmrdsUsers)
+
+		updatebody := &models.PVMInstanceUpdate{SoftwareLicenses: sl}
+		_, err = client.Update(instanceID, updatebody)
+		if err != nil {
+			return diag.FromErr(err)
+		}
+		_, err = isWaitForPIInstanceSoftwareLicenses(ctx, client, instanceID, sl)
+		if err != nil {
+			return diag.FromErr(err)
+		}
+	}
 
+	return resourceIBMPIInstanceRead(ctx, d, meta)
 }
 
 func resourceIBMPIInstanceDelete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
@@ -856,6 +913,59 @@ func isPIInstanceRefreshFunc(client *st.IBMPIInstanceClient, id, instanceReadySt
 	}
 }
 
+func isWaitForPIInstanceSoftwareLicenses(ctx context.Context, client *st.IBMPIInstanceClient, id string, softwareLicenses *models.SoftwareLicenses) (interface{}, error) {
+	log.Printf("Waiting for PIInstance Software Licenses (%s) to be updated ", id)
+
+	queryTimeOut := activeTimeOut
+
+	stateConf := &resource.StateChangeConf{
+		Pending:    []string{"notdone"},
+		Target:     []string{"done"},
+		Refresh:    isPIInstanceSoftwareLicensesRefreshFunc(client, id, softwareLicenses),
+		Delay:      90 * time.Second,
+		MinTimeout: queryTimeOut,
+		Timeout:    120 * time.Minute,
+	}
+
+	return stateConf.WaitForStateContext(ctx)
+}
+
+func isPIInstanceSoftwareLicensesRefreshFunc(client *st.IBMPIInstanceClient, id string, softwareLicenses *models.SoftwareLicenses) resource.StateRefreshFunc {
+	return func() (interface{}, string, error) {
+
+		pvm, err := client.Get(id)
+		if err != nil {
+			return nil, "", err
+		}
+
+		// Check that each software license we modified has been updated
+		if softwareLicenses.IbmiCSS != nil {
+			if *softwareLicenses.IbmiCSS != *pvm.SoftwareLicenses.IbmiCSS {
+				return pvm, "notdone", nil
+			}
+		}
+
+		if softwareLicenses.IbmiPHA != nil {
+			if *softwareLicenses.IbmiPHA != *pvm.SoftwareLicenses.IbmiPHA {
+				return pvm, "notdone", nil
+			}
+		}
+
+		if softwareLicenses.IbmiRDS != nil {
+			// If the update set IBMiRDS to false, don't check IBMiRDSUsers as it will be updated on the terraform side on the read
+			if !*softwareLicenses.IbmiRDS {
+				if *softwareLicenses.IbmiRDS != *pvm.SoftwareLicenses.IbmiRDS {
+					return pvm, "notdone", nil
+				}
+			} else if (*softwareLicenses.IbmiRDS != *pvm.SoftwareLicenses.IbmiRDS) || (softwareLicenses.IbmiRDSUsers != pvm.SoftwareLicenses.IbmiRDSUsers) {
+				return pvm, "notdone", nil
+			}
+		}
+
+		return pvm, "done", nil
+	}
+}
+
 // This function takes the input string and encodes into base64 if isn't already encoded
 func encodeBase64(userData string) string {
 	_, err := base64.StdEncoding.DecodeString(userData)
@@ -1285,18 +1395,15 @@ func createPVMInstance(d *schema.ResourceData, client *st.IBMPIInstanceClient, i
 	if spp, ok := d.GetOk(Arg_PIInstanceSharedProcessorPool); ok {
 		body.SharedProcessorPool = spp.(string)
 	}
-
-	if lrc, ok := d.GetOk(helpers.PIInstanceLicenseRepositoryCapacity); ok {
-		// check if using vtl image
-		// check if vtl image is stock image
-		imageData, err := imageClient.GetStockImage(imageid)
+	imageData, err := imageClient.GetStockImage(imageid)
+	if err != nil {
+		// check if vtl image is cloud instance image
+		imageData, err = imageClient.Get(imageid)
 		if err != nil {
-			// check if vtl image is cloud instance image
-			imageData, err = imageClient.Get(imageid)
-			if err != nil {
-				return nil, fmt.Errorf("image doesn't exist. %e", err)
-			}
+			return nil, fmt.Errorf("image doesn't exist. %e", err)
 		}
+	}
+	if lrc, ok := d.GetOk(helpers.PIInstanceLicenseRepositoryCapacity); ok {
 
 		if imageData.Specifications.ImageType == "stock-vtl" {
 			body.LicenseRepositoryCapacity = int64(lrc.(int))
@@ -1305,6 +1412,31 @@ func createPVMInstance(d *schema.ResourceData, client *st.IBMPIInstanceClient, i
 		}
 	}
 
+	if imageData.Specifications.OperatingSystem == OS_IBMI {
+		// Default value
+		falseBool := false
+		sl := &models.SoftwareLicenses{
+			IbmiCSS:      &falseBool,
+			IbmiPHA:      &falseBool,
+			IbmiRDS:      &falseBool,
+			IbmiRDSUsers: 0,
+		}
+		if ibmiCSS, ok := d.GetOk(PIInstanceIbmiCSS); ok {
+			sl.IbmiCSS = flex.PtrToBool(ibmiCSS.(bool))
+		}
+		if ibmiPHA, ok := d.GetOk(PIInstanceIbmiPHA); ok {
+			sl.IbmiPHA = flex.PtrToBool(ibmiPHA.(bool))
+		}
+		if ibmrdsUsers, ok := d.GetOk(PIInstanceIbmiRDSUsers); ok {
+			if ibmrdsUsers.(int) < 0 {
+				return nil, fmt.Errorf("request with IBMi Rational Dev Studio property requires IBMi Rational Dev Studio number of users")
+			}
+			sl.IbmiRDS = flex.PtrToBool(ibmrdsUsers.(int) > 0)
+			sl.IbmiRDSUsers = int64(ibmrdsUsers.(int))
+		}
+		body.SoftwareLicenses = sl
+	}
+
 	pvmList, err := client.Create(body)
 
 	if err != nil {

ibm/service/power/resource_ibm_pi_instance_test.go

@@ -139,6 +139,41 @@ func testAccCheckIBMPIInstanceDeploymentTypeConfig(name, instanceHealthStatus st
 	`, acc.Pi_cloud_instance_id, name, acc.Pi_image, acc.Pi_network_name, instanceHealthStatus)
 }
 
+func testAccCheckIBMPIInstanceIBMiLicense(name, instanceHealthStatus string, IBMiCSS bool, IBMiRDSUsers int) string {
+	return fmt.Sprintf(`
+		  data "ibm_pi_image" "power_image" {
+			pi_cloud_instance_id = "%[1]s"
+			pi_image_name        = "%[3]s"
+		  }
+		  data "ibm_pi_network" "power_networks" {
+			pi_cloud_instance_id = "%[1]s"
+			pi_network_name      = "%[4]s"
+		  }
+		  resource "ibm_pi_volume" "power_volume" {
+			pi_cloud_instance_id = "%[1]s"
+			pi_volume_size       = 1
+			pi_volume_name       = "%[2]s"
+			pi_volume_type        = "tier3"
+		  }
+		  resource "ibm_pi_instance" "power_instance" {
+			pi_memory             = "2"
+			pi_processors         = "0.25"
+			pi_instance_name      = "%[2]s"
+			pi_proc_type          = "shared"
+			pi_image_id           = data.ibm_pi_image.power_image.id
+			pi_sys_type           = "s922"
+			pi_cloud_instance_id  = "%[1]s"
+			pi_storage_pool       = data.ibm_pi_image.power_image.storage_pool
+			pi_health_status      = "%[5]s"
+			pi_volume_ids         = [ibm_pi_volume.power_volume.volume_id]
+			pi_network {
+				network_id = data.ibm_pi_network.power_networks.id
+			}
+			pi_ibmi_css 		  = %[6]t
+			pi_ibmi_rds_users 	  = %[7]d
+		  }`, acc.Pi_cloud_instance_id, name, acc.Pi_image, acc.Pi_network_name, instanceHealthStatus, IBMiCSS, IBMiRDSUsers)
+}
+
 func testAccIBMPIInstanceNetworkConfig(name, privateNetIP string) string {
 	return fmt.Sprintf(`
 	resource "ibm_pi_key" "key" {
@@ -319,6 +354,40 @@ func TestAccIBMPIInstanceDeploymentType(t *testing.T) {
 	})
 }
 
+func TestAccIBMPIInstanceIBMiLicense(t *testing.T) {
+	instanceRes := "ibm_pi_instance.power_instance"
+	name := fmt.Sprintf("tf-pi-instance-%d", acctest.RandIntRange(10, 100))
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { acc.TestAccPreCheck(t) },
+		Providers:    acc.TestAccProviders,
+		CheckDestroy: testAccCheckIBMPIInstanceDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccCheckIBMPIInstanceIBMiLicense(name, helpers.PIInstanceHealthOk, true, 2),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckIBMPIInstanceExists(instanceRes),
+					resource.TestCheckResourceAttr(instanceRes, "pi_instance_name", name),
+					resource.TestCheckResourceAttr(instanceRes, "status", "ACTIVE"),
+					resource.TestCheckResourceAttr(instanceRes, "pi_ibmi_css", "true"),
+					resource.TestCheckResourceAttr(instanceRes, "pi_ibmi_rds", "true"),
+					resource.TestCheckResourceAttr(instanceRes, "pi_ibmi_rds_users", "2"),
+				),
+			},
+			{
+				Config: testAccCheckIBMPIInstanceIBMiLicense(name, helpers.PIInstanceHealthOk, false, 0),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckIBMPIInstanceExists(instanceRes),
+					testAccCheckIBMPIInstanceStatus(instanceRes, "ACTIVE"),
+					resource.TestCheckResourceAttr(instanceRes, "pi_instance_name", name),
+					resource.TestCheckResourceAttr(instanceRes, "pi_ibmi_css", "false"),
+					resource.TestCheckResourceAttr(instanceRes, "pi_ibmi_rds", "false"),
+					resource.TestCheckResourceAttr(instanceRes, "pi_ibmi_rds_users", "0"),
+				),
+			},
+		},
+	})
+}
+
 func TestAccIBMPIInstanceNetwork(t *testing.T) {
 	instanceRes := "ibm_pi_instance.power_instance"
 	name := fmt.Sprintf("tf-pi-instance-%d", acctest.RandIntRange(10, 100))

website/docs/d/pi_instance.html.markdown

@@ -84,3 +84,9 @@ In addition to all argument reference list, you can access the following attribu
 - `storage_type` - (String) The storage type where server is deployed.
 - `virtual_cores_assigned` - (Integer) The virtual cores that are assigned to the instance.
 - `volumes` - (List of strings) The list of volume IDs that are attached to the instance.
+
+  **Notes** Ibmi software licenses for IBMi virtual server instances --software licenses currently only supports IBMi instances
+- `pi_ibmi_css` - (Boolean) IBMi Cloud Storage Solution.
+- `pi_ibmi_pha` - (Boolean) IBMi Power High Availability.
+- `pi_ibmi_rds` - (Boolean) IBMi Rational Dev Studio.
+- `pi_ibmi_rds_users` - (Integer) IBMi Rational Dev Studio Number of User Licenses.