issue with partition

Author: Laure-di

internal/services/baremetal/easy_partitioning_data_source.go

@@ -2,14 +2,14 @@ package baremetal
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 	"github.com/scaleway/scaleway-sdk-go/api/baremetal/v1"
 	"github.com/scaleway/scaleway-sdk-go/scw"
 	"github.com/scaleway/terraform-provider-scaleway/v2/internal/dsf"
 	"github.com/scaleway/terraform-provider-scaleway/v2/internal/verify"
-	"strings"
 )
 
 func DataEasyPartitioning() *schema.Resource {
@@ -34,86 +34,243 @@ func DataEasyPartitioning() *schema.Resource {
 				Default:     true,
 				Description: "set swap partition",
 			},
-			"ext_4": {
+			"extra_partition": {
 				Type:        schema.TypeBool,
 				Optional:    true,
 				Default:     true,
 				Description: "set extra ext_4 partition",
 			},
-			"ext_4_name": { //TODO change to mount point
+			"ext_4_mountpoint": { //TODO change to mount point
 				Type:        schema.TypeString,
 				Optional:    true,
-				Default:     "/data",
+				Default:     "/hello",
 				Description: "Mount point must be an absolute path with alphanumeric characters and underscores",
 			},
-			"custom_partition": {
+			"json_partition": {
 				Type:        schema.TypeString,
 				Optional:    true,
 				Description: "The partitioning schema in json format",
 			},
+			"disks": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"device": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"partitions": {
+							Type:     schema.TypeList,
+							Computed: true,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"label": {
+										Type:     schema.TypeString,
+										Computed: true,
+									},
+									"number": {
+										Type:     schema.TypeInt,
+										Computed: true,
+									},
+									"size": {
+										Type:     schema.TypeString, // scw.Size implements String()
+										Computed: true,
+									},
+									"use_all_available_space": {
+										Type:     schema.TypeBool,
+										Computed: true,
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+			"raids": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"name": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"level": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"devices": {
+							Type:     schema.TypeList,
+							Computed: true,
+							Elem:     &schema.Schema{Type: schema.TypeString},
+						},
+					},
+				},
+			},
+			"filesystems": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"device": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"format": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"mountpoint": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+					},
+				},
+			},
 		},
 	}
 }
 
-func removeSwap(defaultDisks []*baremetal.SchemaDisk, extraPartition bool) []*baremetal.SchemaDisk {
-	var swapSize scw.Size
-	var newPartition []*baremetal.SchemaPartition
-	var newDisks []*baremetal.SchemaDisk
-	var disk *baremetal.SchemaDisk
+func removeSwap(originalDisks []*baremetal.SchemaDisk, withExtraPartition bool) []*baremetal.SchemaDisk {
+	var result []*baremetal.SchemaDisk
 
-	for _, oldDisk := range defaultDisks {
-		for _, partition := range oldDisk.Partitions {
-			if partition.Label == "swap" {
-				swapSize = partition.Size
+	for _, disk := range originalDisks {
+		i := 1
+		newPartitions := []*baremetal.SchemaPartition{}
+		for _, p := range disk.Partitions {
+			if p.Label == "swap" {
 				continue
 			}
-			if partition.Label == "boot" && !extraPartition {
-				partition.Size += swapSize
-			} else if partition.Label == "boot" && extraPartition {
-				partition.Size = 20000000000
+			if p.Label == "root" {
+				if !withExtraPartition {
+					p.Size = 0
+					p.UseAllAvailableSpace = true
+				} else {
+					p.Size = 20000000000
+				}
 			}
-			newPartition = append(newPartition, partition)
+			p.Number = uint32(i)
+			i++
+			newPartitions = append(newPartitions, p)
 		}
-		disk.Device = oldDisk.Device
-		disk.Partitions = newPartition
-		newDisks = append(newDisks, oldDisk)
+		result = append(result, &baremetal.SchemaDisk{
+			Device:     disk.Device,
+			Partitions: newPartitions,
+		})
 	}
-	return newDisks
+	return result
 }
 
-"raids": [
-{
-"name": "/dev/md2",
-"level": "raid_level_1",
-"devices": [
-"/dev/nvme0n1p5",
-"/dev/nvme1n1p4"
-]
+func addExtraPartition(mountpoint string, newDisksSchema []*baremetal.SchemaDisk, defaultPartitionSchema *baremetal.Schema) *baremetal.Schema {
+	raidDevices := []string{}
+
+	for _, disk := range newDisksSchema {
+		partIndex := uint32(len(disk.Partitions)) + 1
+		deviceIndex := partIndex + 1
+		data := &baremetal.SchemaPartition{
+			Label:                baremetal.SchemaPartitionLabel("data"),
+			Number:               partIndex,
+			Size:                 0,
+			UseAllAvailableSpace: true,
+		}
+		disk.Partitions = append(disk.Partitions, data)
+
+		device := fmt.Sprintf("%sp%d", disk.Device, deviceIndex)
+		raidDevices = append(raidDevices, device)
+		deviceIndex--
+	}
+
+	filesystem := &baremetal.SchemaFilesystem{
+		Device:     "/dev/md2",
+		Format:     "ext4",
+		Mountpoint: mountpoint,
+	}
+	defaultPartitionSchema.Filesystems = append(defaultPartitionSchema.Filesystems, filesystem)
+
+	raid := &baremetal.SchemaRAID{
+		Name:    "/dev/md2",
+		Level:   baremetal.SchemaRAIDLevelRaidLevel1,
+		Devices: raidDevices,
+	}
+	defaultPartitionSchema.Raids = append(defaultPartitionSchema.Raids, raid)
+	defaultPartitionSchema.Disks = newDisksSchema
+
+	return defaultPartitionSchema
 }
-],
-"filesystems": [
-{
-"device": "/dev/md2",
-"format": "ext4",
-"mountpoint": "/home"
+
+func manageRootSize(originalDisks []*baremetal.SchemaDisk, withSwap bool, withExtraPartition bool) {
+	for _, disk := range originalDisks {
+		for _, partition := range disk.Partitions {
+			if partition.Label == "root" {
+				if !withSwap && !withExtraPartition {
+					partition.Size = 0
+					partition.UseAllAvailableSpace = true
+				}
+				if withExtraPartition {
+					partition.Size = 20000000000
+				}
+			}
+		}
+	}
 }
-],
 
-{
-"label": "data",
-"number": 4,
-"size": 0,
-"use_all_available_space": true
+func flattenDisksSchema(disks []*baremetal.SchemaDisk) []map[string]interface{} {
+	var out []map[string]interface{}
+	for _, d := range disks {
+		if d == nil {
+			continue
+		}
+
+		parts := make([]map[string]interface{}, 0, len(d.Partitions))
+		for _, p := range d.Partitions {
+			if p == nil {
+				continue
+			}
+			parts = append(parts, map[string]interface{}{
+				"label":                   string(p.Label),
+				"number":                  int(p.Number),
+				"size":                    p.Size.String(),
+				"use_all_available_space": p.UseAllAvailableSpace,
+			})
+		}
+
+		out = append(out, map[string]interface{}{
+			"device":     d.Device,
+			"partitions": parts,
+		})
+	}
+	return out
 }
 
-func addExtraPartition(name string, extraPartition []*baremetal.SchemaDisk, defaultPartitionSchema *baremetal.Schema) *baremetal.Schema {
-	_, label, _ := strings.Cut(name, "/")
-	data := &baremetal.SchemaPartition{
-		Label:                "",
-		Number:               0,
-		Size:                 0,
-		UseAllAvailableSpace: false,
+func flattenRaids(raids []*baremetal.SchemaRAID) []map[string]interface{} {
+	var out []map[string]interface{}
+	for _, r := range raids {
+		if r == nil {
+			continue
+		}
+		out = append(out, map[string]interface{}{
+			"name":    r.Name,
+			"level":   string(r.Level),
+			"devices": r.Devices,
+		})
+	}
+	return out
+}
+
+func flattenFilesystems(fsList []*baremetal.SchemaFilesystem) []map[string]interface{} {
+	var out []map[string]interface{}
+	for _, fs := range fsList {
+		if fs == nil {
+			continue
+		}
+		out = append(out, map[string]interface{}{
+			"device":     fs.Device,
+			"format":     string(fs.Format),
+			"mountpoint": fs.Mountpoint,
+		})
 	}
+	return out
 }
 
 func dataEasyPartitioningRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
@@ -161,27 +318,57 @@ func dataEasyPartitioningRead(ctx context.Context, d *schema.ResourceData, m int
 	}
 
 	extraPart := d.Get("extra_partition").(bool)
+	swap := d.Get("swap").(bool)
+
+	if swap && !extraPart {
+		jsonSchema, _ := json.Marshal(defaultPartitioningSchema)
+		d.SetId(fmt.Sprintf("%s-%s", offerID, osID))
+		_ = d.Set("json_partition", string(jsonSchema))
+		_ = d.Set("disks", flattenDisksSchema(defaultPartitioningSchema.Disks))
+		_ = d.Set("raids", flattenRaids(defaultPartitioningSchema.Raids))
+		_ = d.Set("filesystems", flattenFilesystems(defaultPartitioningSchema.Filesystems))
+
+		return nil
+	}
+
+	manageRootSize(defaultPartitioningSchema.Disks, swap, extraPart)
 
 	var newDiskSchema []*baremetal.SchemaDisk
-	if swap := d.Get("swap"); !swap.(bool) {
+	if !swap {
 		newDiskSchema = removeSwap(defaultPartitioningSchema.Disks, extraPart)
 	}
 
-	var newCustomPartition []*baremetal.Schema
+	if newDiskSchema == nil {
+		newDiskSchema = defaultPartitioningSchema.Disks
+	}
+
+	var newCustomPartition *baremetal.Schema
 	if extraPart {
-		name := d.Get("ext_4_name").(string)
-		newCustomPartition = addExtraPartition(name, newDiskSchema, defaultPartitioningSchema)
-	}
-
-	defaultPartitioningSchema.Disks = append(defaultPartitioningSchema.Disks)
-	//TODO checker si offer custom partitoning2l;
-	//TODO checker si offer et os compatible
-	//TODO get default partitioning
-	//TODO remove swap and increase boot size
-	//TODO
-	//TODO unmarshall
-	//TODO replacer les valeurs
-	//TODO marshal
+		mountpoint := d.Get("ext_4_mountpoint").(string)
+		newCustomPartition = addExtraPartition(mountpoint, newDiskSchema, defaultPartitioningSchema)
+	}
+
+	err = api.ValidatePartitioningSchema(&baremetal.ValidatePartitioningSchemaRequest{
+		Zone:               fallBackZone,
+		OfferID:            offerID,
+		OsID:               osID,
+		PartitioningSchema: defaultPartitioningSchema,
+	})
+
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	jsonSchema, err := json.Marshal(newCustomPartition)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	d.SetId(fmt.Sprintf("%s-%s", offerID, osID))
+	_ = d.Set("json_partition", string(jsonSchema))
+	_ = d.Set("disks", flattenDisksSchema(newCustomPartition.Disks))
+	_ = d.Set("raids", flattenRaids(newCustomPartition.Raids))
+	_ = d.Set("filesystems", flattenFilesystems(newCustomPartition.Filesystems))
 
 	return nil
 }