Add some resources and data-resources, fix bugs

decort/resource_image.go

@@ -25,11 +25,12 @@ Visit https://github.com/rudecs/terraform-provider-decort for full source code p
 package decort
 
 import (
+	"errors"
 	"net/url"
 	"strconv"
 
+	"github.com/hashicorp/terraform-plugin-sdk/helper/customdiff"
 	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
-	"github.com/hashicorp/terraform-plugin-sdk/helper/validation"
 	log "github.com/sirupsen/logrus"
 )
 
@@ -46,8 +47,12 @@ func resourceImageCreate(d *schema.ResourceData, m interface{}) error {
 
 	tstr := d.Get("drivers").([]interface{})
 	temp := ""
-	for _, str := range tstr {
+	l := len(tstr)
+	for i, str := range tstr {
 		s := "\"" + str.(string) + "\""
+		if i != (l - 1) {
+			s += ","
+		}
 		temp = temp + s
 	}
 	temp = "[" + temp + "]"
@@ -62,9 +67,6 @@ func resourceImageCreate(d *schema.ResourceData, m interface{}) error {
 	if password, ok := d.GetOk("password"); ok {
 		urlValues.Add("password", password.(string))
 	}
-	if accountId, ok := d.GetOk("account_id"); ok {
-		urlValues.Add("accountId", accountId.(string))
-	}
 	if accountId, ok := d.GetOk("account_id"); ok {
 		urlValues.Add("accountId", strconv.Itoa(accountId.(int)))
 	}
@@ -84,7 +86,14 @@ func resourceImageCreate(d *schema.ResourceData, m interface{}) error {
 		urlValues.Add("architecture", architecture.(string))
 	}
 
-	imageId, err := controller.decortAPICall("POST", imageCreateAPI, urlValues)
+	api := ""
+	isSync := d.Get("sync").(bool)
+	if !isSync {
+		api = imageCreateAPI
+	} else {
+		api = imageSyncCreateAPI
+	}
+	imageId, err := controller.decortAPICall("POST", api, urlValues)
 	if err != nil {
 		return err
 	}
@@ -101,6 +110,11 @@ func resourceImageCreate(d *schema.ResourceData, m interface{}) error {
 	d.Set("bootable", image.Bootable)
 	//d.Set("image_id", image.ImageId)
 
+	err = resourceImageRead(d, m)
+	if err != nil {
+		return err
+	}
+
 	return nil
 }
 
@@ -113,23 +127,44 @@ func resourceImageRead(d *schema.ResourceData, m interface{}) error {
 		return err
 	}
 
-	d.Set("image_id", image.ImageId)
 	d.Set("name", image.Name)
+	d.Set("drivers", image.Drivers)
 	d.Set("url", image.Url)
 	d.Set("gid", image.Gid)
+	d.Set("image_id", image.ImageId)
 	d.Set("boot_type", image.Boottype)
 	d.Set("image_type", image.Imagetype)
-	d.Set("drivers", image.Drivers)
-	d.Set("hot_resize", image.Hotresize)
-	d.Set("username", image.Username)
-	d.Set("password", image.Password)
-	d.Set("account_id", image.AccountId)
-	d.Set("username_dl", image.UsernameDL)
-	d.Set("password_dl", image.PasswordDL)
-	d.Set("sep_id", image.SepId)
-	d.Set("pool_name", image.PoolName)
-	d.Set("architecture", image.Architecture)
 	d.Set("bootable", image.Bootable)
+	d.Set("sep_id", image.SepId)
+	d.Set("unc_path", image.UNCPath)
+	d.Set("link_to", image.LinkTo)
+	d.Set("status", image.Status)
+	d.Set("tech_status", image.TechStatus)
+	d.Set("version", image.Version)
+	d.Set("size", image.Size)
+	d.Set("enabled", image.Enabled)
+	d.Set("computeci_id", image.ComputeciId)
+	d.Set("pool_name", image.PoolName)
+	d.Set("username", image.Username)
+	d.Set("username_dl", image.UsernameDL)
+	d.Set("password", image.Password)
+	d.Set("password_dl", image.PasswordDL)
+	d.Set("account_id", image.AccountId)
+	d.Set("guid", image.Guid)
+	d.Set("milestones", image.Milestones)
+	d.Set("provider_name", image.ProviderName)
+	d.Set("purge_attempts", image.PurgeAttempts)
+	d.Set("reference_id", image.ReferenceId)
+	d.Set("res_id", image.ResId)
+	d.Set("res_name", image.ResName)
+	d.Set("rescuecd", image.Rescuecd)
+	d.Set("architecture", image.Architecture)
+	d.Set("meta", flattenMeta(image.Meta))
+	d.Set("hot_resize", image.Hotresize)
+	d.Set("history", flattenHistory(image.History))
+	d.Set("last_modified", image.LastModified)
+	d.Set("desc", image.Desc)
+	d.Set("shared_with", image.SharedWith)
 
 	return nil
 }
@@ -148,7 +183,11 @@ func resourceImageDelete(d *schema.ResourceData, m interface{}) error {
 	controller := m.(*ControllerCfg)
 	urlValues := &url.Values{}
 	urlValues.Add("imageId", strconv.Itoa(d.Get("image_id").(int)))
-	urlValues.Add("reason", "")
+	if reason, ok := d.GetOk("reason"); ok {
+		urlValues.Add("reason", reason.(string))
+	} else {
+		urlValues.Add("reason", "")
+	}
 	if permanently, ok := d.GetOk("permanently"); ok {
 		urlValues.Add("permanently", strconv.FormatBool(permanently.(bool)))
 	}
@@ -186,20 +225,6 @@ func resourceImageEditName(d *schema.ResourceDiff, m interface{}) error {
 	if err != nil {
 		return err
 	}
-	return nil
-}
-
-func resourceImageLink(d *schema.ResourceDiff, m interface{}) error {
-	log.Debugf("resourceImageLink: called for %s, id: %s", d.Get("name").(string), d.Id())
-	c := m.(*ControllerCfg)
-	urlValues := &url.Values{}
-	link := d.Get("link").(map[string]interface{})
-	urlValues.Add("imageId", strconv.Itoa(link["image_id"].(int)))
-	urlValues.Add("targetId", strconv.Itoa(link["target_id"].(int)))
-	_, err := c.decortAPICall("POST", imageLinkAPI, urlValues)
-	if err != nil {
-		return err
-	}
 
 	return nil
 }
@@ -210,25 +235,142 @@ func resourceImageEdit(d *schema.ResourceData, m interface{}) error {
 	urlValues := &url.Values{}
 	urlValues.Add("imageId", strconv.Itoa(d.Get("image_id").(int)))
 	urlValues.Add("name", d.Get("name").(string))
-	if username, ok := d.GetOk("username"); ok {
-		urlValues.Add("username", username.(string))
-	}
-	if password, ok := d.GetOk("password"); ok {
-		urlValues.Add("password", password.(string))
-	}
-	if accountId, ok := d.GetOk("account_id"); ok {
-		urlValues.Add("accountId", strconv.Itoa(accountId.(int)))
-	}
-	if bootable, ok := d.GetOk("bootable"); ok {
-		urlValues.Add("bootable", strconv.FormatBool(bootable.(bool)))
-	}
-	if hotresize, ok := d.GetOk("hot_resize"); ok {
-		urlValues.Add("hotresize", strconv.FormatBool(hotresize.(bool)))
-	}
+
+	urlValues.Add("username", d.Get("username").(string))
+	urlValues.Add("password", d.Get("password").(string))
+	urlValues.Add("accountId", strconv.Itoa(d.Get("account_id").(int)))
+	urlValues.Add("bootable", strconv.FormatBool(d.Get("bootable").(bool)))
+	urlValues.Add("hotresize", strconv.FormatBool(d.Get("hot_resize").(bool)))
+
+	//_, err := c.decortAPICall("POST", imageEditAPI, urlValues)
 	_, err := c.decortAPICall("POST", imageEditAPI, urlValues)
+	if err != nil {
+		err = resourceImageRead(d, m)
+		if err != nil {
+			return err
+		}
+		return nil
+	}
+	err = resourceImageRead(d, m)
 	if err != nil {
 		return err
 	}
+
+	return nil
+}
+
+func resourceImageChangeEnabled(d *schema.ResourceDiff, m interface{}) error {
+	var api string
+
+	c := m.(*ControllerCfg)
+	urlValues := &url.Values{}
+	urlValues.Add("imageId", strconv.Itoa(d.Get("image_id").(int)))
+	if d.Get("enabled").(bool) {
+		api = imageEnableAPI
+	} else {
+		api = imageDisableAPI
+	}
+	resp, err := c.decortAPICall("POST", api, urlValues)
+	if err != nil {
+		return err
+	}
+	res, err := strconv.ParseBool(resp)
+	if err != nil {
+		return err
+	}
+	if !res {
+		return errors.New("Cannot enable/disable")
+	}
+	return nil
+}
+
+func resourceImageLink(d *schema.ResourceDiff, m interface{}) error {
+	log.Debugf("resourceVirtualImageLink: called for %s, id: %s", d.Get("name").(string), d.Id())
+	c := m.(*ControllerCfg)
+	urlValues := &url.Values{}
+	urlValues.Add("imageId", strconv.Itoa(d.Get("image_id").(int)))
+	urlValues.Add("targetId", strconv.Itoa(d.Get("link_to").(int)))
+	_, err := c.decortAPICall("POST", imageLinkAPI, urlValues)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func resourceImageShare(d *schema.ResourceDiff, m interface{}) error {
+	log.Debugf("resourceImageShare: called for %s, id: %s", d.Get("name").(string), d.Id())
+	c := m.(*ControllerCfg)
+	urlValues := &url.Values{}
+	urlValues.Add("imageId", strconv.Itoa(d.Get("image_id").(int)))
+	accIds := d.Get("shared_with").([]interface{})
+	temp := ""
+	l := len(accIds)
+	for i, accId := range accIds {
+		s := strconv.Itoa(accId.(int))
+		if i != (l - 1) {
+			s += ",\n"
+		} else {
+			s += "\n"
+		}
+		temp = temp + s
+	}
+	temp = "[" + temp + "]"
+	urlValues.Add("accounts", temp)
+	_, err := c.decortAPICall("POST", imageShareAPI, urlValues)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func resourceImageChangeComputeci(d *schema.ResourceDiff, m interface{}) error {
+	c := m.(*ControllerCfg)
+	urlValues := &url.Values{}
+
+	urlValues.Add("imageId", strconv.Itoa(d.Get("image_id").(int)))
+	computeci := d.Get("computeci_id").(int)
+
+	api := ""
+
+	if computeci == 0 {
+		api = imageComputeciUnsetAPI
+	} else {
+		urlValues.Add("computeciId", strconv.Itoa(computeci))
+		api = imageComputeciSetAPI
+	}
+
+	_, err := c.decortAPICall("POST", api, urlValues)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func resourceImageUpdateNodes(d *schema.ResourceDiff, m interface{}) error {
+	log.Debugf("resourceImageUpdateNodes: called for %s, id: %s", d.Get("name").(string), d.Id())
+	c := m.(*ControllerCfg)
+	urlValues := &url.Values{}
+	urlValues.Add("imageId", strconv.Itoa(d.Get("image_id").(int)))
+	enabledStacks := d.Get("enabled_stacks").([]interface{})
+	temp := ""
+	l := len(enabledStacks)
+	for i, stackId := range enabledStacks {
+		s := stackId.(string)
+		if i != (l - 1) {
+			s += ","
+		}
+		temp = temp + s
+	}
+	temp = "[" + temp + "]"
+	urlValues.Add("enabledStacks", temp)
+	_, err := c.decortAPICall("POST", imageUpdateNodesAPI, urlValues)
+	if err != nil {
+		return err
+	}
+
 	return nil
 }
 
@@ -237,129 +379,241 @@ func resourceImageSchemaMake() map[string]*schema.Schema {
 		"name": {
 			Type:        schema.TypeString,
 			Required:    true,
-			ForceNew:    true,
 			Description: "Name of the rescue disk",
 		},
 		"url": {
 			Type:        schema.TypeString,
 			Required:    true,
-			ForceNew:    true,
 			Description: "URL where to download media from",
 		},
 		"gid": {
-			Type:         schema.TypeInt,
-			Required:     true,
-			ForceNew:     true,
-			ValidateFunc: validation.IntBetween(1, 65535),
-			Description:  "grid (platform) ID where this template should be create in",
+			Type:        schema.TypeInt,
+			Required:    true,
+			Description: "grid (platform) ID where this template should be create in",
 		},
 		"boot_type": {
-			Type:         schema.TypeString,
-			Required:     true,
-			ForceNew:     true,
-			ValidateFunc: validation.StringInSlice([]string{"bios", "uefi"}, false),
-			Description:  "Boot type of image bios or uefi",
+			Type:        schema.TypeString,
+			Required:    true,
+			Description: "Boot type of image bios or uefi",
 		},
 		"image_type": {
 			Type:        schema.TypeString,
 			Required:    true,
-			ForceNew:    true,
 			Description: "Image type linux, windows or other",
 		},
 		"drivers": {
 			Type:     schema.TypeList,
 			Required: true,
-			MinItems: 1,
 			Elem: &schema.Schema{
 				Type: schema.TypeString,
 			},
 			Description: "List of types of compute suitable for image. Example: [ \"KVM_X86\" ]",
 		},
+		"meta": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeString,
+			},
+			Description: "meta",
+		},
 		"hot_resize": {
 			Type:        schema.TypeBool,
 			Optional:    true,
+			Computed:    true,
 			Description: "Does this machine supports hot resize",
 		},
 		"username": {
 			Type:        schema.TypeString,
 			Optional:    true,
+			Computed:    true,
 			Description: "Optional username for the image",
 		},
 		"password": {
 			Type:        schema.TypeString,
 			Optional:    true,
+			Computed:    true,
 			Description: "Optional password for the image",
 		},
 		"account_id": {
 			Type:        schema.TypeInt,
 			Optional:    true,
+			Computed:    true,
 			Description: "AccountId to make the image exclusive",
 		},
 		"username_dl": {
 			Type:        schema.TypeString,
 			Optional:    true,
+			Computed:    true,
 			Description: "username for upload binary media",
 		},
 		"password_dl": {
 			Type:        schema.TypeString,
 			Optional:    true,
+			Computed:    true,
 			Description: "password for upload binary media",
 		},
 		"sep_id": {
 			Type:        schema.TypeInt,
 			Optional:    true,
+			Computed:    true,
 			Description: "storage endpoint provider ID",
 		},
 		"pool_name": {
 			Type:        schema.TypeString,
 			Optional:    true,
+			Computed:    true,
 			Description: "pool for image create",
 		},
 		"architecture": {
-			Type:         schema.TypeString,
-			Optional:     true,
-			ValidateFunc: validation.StringInSlice([]string{"X86_64", "PPC64_LE"}, false),
-			Description:  "binary architecture of this image, one of X86_64 of PPC64_LE",
+			Type:        schema.TypeString,
+			Optional:    true,
+			Computed:    true,
+			Description: "binary architecture of this image, one of X86_64 of PPC64_LE",
 		},
 		"image_id": {
 			Type:        schema.TypeInt,
+			Optional:    true,
 			Computed:    true,
 			Description: "image id",
 		},
 		"permanently": {
 			Type:        schema.TypeBool,
 			Optional:    true,
+			Computed:    true,
 			Description: "Whether to completely delete the image",
 		},
 		"bootable": {
 			Type:        schema.TypeBool,
 			Optional:    true,
+			Computed:    true,
 			Description: "Does this image boot OS",
 		},
-		"virtual": {
-			Type:        schema.TypeMap,
-			Optional:    true,
-			Description: "Create virtual image",
-			Elem: &schema.Resource{
-				Schema: map[string]*schema.Schema{
-					"name": {
-						Type:        schema.TypeString,
-						Required:    true,
-						Description: "name of the virtual image to create",
-					},
-					"v_image_id": {
-						Type:        schema.TypeInt,
-						Computed:    true,
-						Description: "",
-					},
-				},
-			},
+		"unc_path": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "unc path",
 		},
 		"link_to": {
 			Type:        schema.TypeInt,
-			Optional:    true,
+			Computed:    true,
 			Description: "",
 		},
+		"status": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "status",
+		},
+		"tech_status": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "tech atatus",
+		},
+		"version": {
+			Type:        schema.TypeString,
+			Computed:    true,
+			Description: "version",
+		},
+		"size": {
+			Type:        schema.TypeInt,
+			Computed:    true,
+			Description: "image size",
+		},
+		"enabled": {
+			Type:     schema.TypeBool,
+			Optional: true,
+			Computed: true,
+		},
+		"computeci_id": {
+			Type:     schema.TypeInt,
+			Optional: true,
+			Computed: true,
+		},
+		"guid": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"milestones": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"provider_name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"purge_attempts": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"reference_id": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"res_id": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"res_name": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"rescuecd": {
+			Type:     schema.TypeBool,
+			Computed: true,
+		},
+		"reason": {
+			Type:     schema.TypeString,
+			Optional: true,
+		},
+		"last_modified": {
+			Type:     schema.TypeInt,
+			Computed: true,
+		},
+		"desc": {
+			Type:     schema.TypeString,
+			Computed: true,
+		},
+		"shared_with": {
+			Type:     schema.TypeList,
+			Optional: true,
+			Computed: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeInt,
+			},
+		},
+		"sync": {
+			Type:        schema.TypeBool,
+			Optional:    true,
+			Default:     false,
+			Description: "Create image from a media identified by URL (in synchronous mode)",
+		},
+		"enabled_stacks": {
+			Type:     schema.TypeList,
+			Optional: true,
+			Elem: &schema.Schema{
+				Type: schema.TypeString,
+			},
+		},
+		"history": {
+			Type:     schema.TypeList,
+			Computed: true,
+			Elem: &schema.Resource{
+				Schema: map[string]*schema.Schema{
+					"guid": {
+						Type:     schema.TypeString,
+						Computed: true,
+					},
+					"id": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+					"timestamp": {
+						Type:     schema.TypeInt,
+						Computed: true,
+					},
+				},
+			},
+		},
 	}
 }
 
@@ -384,20 +638,101 @@ func resourceImage() *schema.Resource {
 			Delete:  &Timeout60s,
 			Default: &Timeout60s,
 		},
-		/*CustomizeDiff: customdiff.All(
-			customdiff.IfValueChange("name", func(old, new, meta interface{}) bool {
-				return !(old.(string) == new.(string))
-			}, resourceImageEditName),
-			customdiff.IfValueChange("link", func(old, new, meta interface{}) bool {
-				o := old.(map[string]interface{})
-				n := new.(map[string]interface{})
-				if o["image_id"].(int) != n["image_id"].(int) && o["target_id"].(int) != n["target_id"].(int) {
+		CustomizeDiff: customdiff.All(
+			customdiff.IfValueChange("enabled", func(old, new, meta interface{}) bool {
+				if old.(bool) != new.(bool) {
 					return true
 				}
 				return false
-			}, resourceImageLink),
-		),*/
+			}, resourceImageChangeEnabled),
+			customdiff.IfValueChange("name", func(old, new, meta interface{}) bool {
+				if old.(string) != new.(string) && old.(string) != "" {
+					return true
+				}
+				return false
+			}, resourceImageEditName),
+			customdiff.IfValueChange("shared_with", func(old, new, meta interface{}) bool {
+				o := old.([]interface{})
+				n := new.([]interface{})
+
+				if len(o) != len(n) {
+					return true
+				} else if len(o) == 0 {
+					return false
+				}
+
+				count := 0
+				for i, v := range n {
+					if v.(int) == o[i].(int) {
+						count++
+					}
+				}
+				if count == 0 {
+					return true
+				}
+				return false
+			}, resourceImageShare),
+			customdiff.IfValueChange("computeci_id", func(old, new, meta interface{}) bool {
+				if old.(int) != new.(int) {
+					return true
+				}
+				return false
+			}, resourceImageChangeComputeci),
+			customdiff.IfValueChange("enabled_stacks", func(old, new, meta interface{}) bool {
+				o := old.([]interface{})
+				n := new.([]interface{})
+
+				if len(o) != len(n) {
+					return true
+				} else if len(o) == 0 {
+					return false
+				}
+				count := 0
+				for i, v := range n {
+					if v.(string) == o[i].(string) {
+						count++
+					}
+				}
+				if count == 0 {
+					return true
+				}
+				return false
+			}, resourceImageUpdateNodes),
+		),
 
 		Schema: resourceImageSchemaMake(),
 	}
 }
+
+func flattenMeta(m []interface{}) []string {
+	output := []string{}
+	for _, item := range m {
+		switch d := item.(type) {
+		case string:
+			output = append(output, d)
+		case int:
+			output = append(output, strconv.Itoa(d))
+		case int64:
+			output = append(output, strconv.FormatInt(d, 10))
+		case float64:
+			output = append(output, strconv.FormatInt(int64(d), 10))
+		default:
+			output = append(output, "")
+		}
+	}
+	return output
+}
+
+func flattenHistory(history []History) []map[string]interface{} {
+	temp := make([]map[string]interface{}, 0)
+	for _, item := range history {
+		t := map[string]interface{}{
+			"id":        item.Id,
+			"guid":      item.Guid,
+			"timestamp": item.Timestamp,
+		}
+
+		temp = append(temp, t)
+	}
+	return temp
+}