package openstack import ( "crypto/md5" "encoding/hex" "fmt" "io" "log" "net/http" "os" "path/filepath" "time" "github.com/gophercloud/gophercloud" "github.com/gophercloud/gophercloud/openstack/imageservice/v2/imagedata" "github.com/gophercloud/gophercloud/openstack/imageservice/v2/images" "github.com/hashicorp/terraform/helper/resource" "github.com/hashicorp/terraform/helper/schema" ) func resourceImagesImageV2() *schema.Resource { return &schema.Resource{ Create: resourceImagesImageV2Create, Read: resourceImagesImageV2Read, Update: resourceImagesImageV2Update, Delete: resourceImagesImageV2Delete, Importer: &schema.ResourceImporter{ State: schema.ImportStatePassthrough, }, Timeouts: &schema.ResourceTimeout{ Create: schema.DefaultTimeout(30 * time.Minute), }, Schema: map[string]*schema.Schema{ "checksum": &schema.Schema{ Type: schema.TypeString, Computed: true, }, "container_format": &schema.Schema{ Type: schema.TypeString, Required: true, ForceNew: true, ValidateFunc: resourceImagesImageV2ValidateContainerFormat, }, "created_at": &schema.Schema{ Type: schema.TypeString, Computed: true, }, "disk_format": &schema.Schema{ Type: schema.TypeString, Required: true, ForceNew: true, ValidateFunc: resourceImagesImageV2ValidateDiskFormat, }, "file": &schema.Schema{ Type: schema.TypeString, Computed: true, }, "image_cache_path": &schema.Schema{ Type: schema.TypeString, Optional: true, Default: fmt.Sprintf("%s/.terraform/image_cache", os.Getenv("HOME")), }, "image_source_url": &schema.Schema{ Type: schema.TypeString, Optional: true, ForceNew: true, ConflictsWith: []string{"local_file_path"}, }, "local_file_path": &schema.Schema{ Type: schema.TypeString, Optional: true, ForceNew: true, ConflictsWith: []string{"image_source_url"}, }, "metadata": &schema.Schema{ Type: schema.TypeMap, Computed: true, }, "min_disk_gb": &schema.Schema{ Type: schema.TypeInt, Optional: true, ForceNew: true, ValidateFunc: validatePositiveInt, Default: 0, }, "min_ram_mb": &schema.Schema{ Type: schema.TypeInt, Optional: true, ForceNew: true, ValidateFunc: validatePositiveInt, Default: 0, }, "name": &schema.Schema{ Type: schema.TypeString, Required: true, ForceNew: false, }, "owner": &schema.Schema{ Type: schema.TypeString, Computed: true, }, "protected": &schema.Schema{ Type: schema.TypeBool, Optional: true, ForceNew: true, Default: false, }, "region": &schema.Schema{ Type: schema.TypeString, Required: true, ForceNew: true, DefaultFunc: schema.EnvDefaultFunc("OS_REGION_NAME", ""), }, "schema": &schema.Schema{ Type: schema.TypeString, Computed: true, }, "size_bytes": &schema.Schema{ Type: schema.TypeInt, Computed: true, }, "status": &schema.Schema{ Type: schema.TypeString, Computed: true, }, "tags": &schema.Schema{ Type: schema.TypeSet, Optional: true, Elem: &schema.Schema{Type: schema.TypeString}, Set: schema.HashString, }, "update_at": &schema.Schema{ Type: schema.TypeString, Computed: true, }, "visibility": &schema.Schema{ Type: schema.TypeString, Optional: true, ForceNew: false, ValidateFunc: resourceImagesImageV2ValidateVisibility, Default: "private", }, }, } } func resourceImagesImageV2Create(d *schema.ResourceData, meta interface{}) error { config := meta.(*Config) imageClient, err := config.imageV2Client(GetRegion(d)) if err != nil { return fmt.Errorf("Error creating OpenStack image client: %s", err) } protected := d.Get("protected").(bool) visibility := resourceImagesImageV2VisibilityFromString(d.Get("visibility").(string)) createOpts := &images.CreateOpts{ Name: d.Get("name").(string), ContainerFormat: d.Get("container_format").(string), DiskFormat: d.Get("disk_format").(string), MinDisk: d.Get("min_disk_gb").(int), MinRAM: d.Get("min_ram_mb").(int), Protected: &protected, Visibility: &visibility, } if v, ok := d.GetOk("tags"); ok { tags := v.(*schema.Set).List() createOpts.Tags = resourceImagesImageV2BuildTags(tags) } d.Partial(true) log.Printf("[DEBUG] Create Options: %#v", createOpts) newImg, err := images.Create(imageClient, createOpts).Extract() if err != nil { return fmt.Errorf("Error creating Image: %s", err) } d.SetId(newImg.ID) // downloading/getting image file props imgFilePath, err := resourceImagesImageV2File(d) if err != nil { return fmt.Errorf("Error opening file for Image: %s", err) } fileSize, fileChecksum, err := resourceImagesImageV2FileProps(imgFilePath) if err != nil { return fmt.Errorf("Error getting file props: %s", err) } // upload imgFile, err := os.Open(imgFilePath) if err != nil { return fmt.Errorf("Error opening file %q: %s", imgFilePath, err) } defer imgFile.Close() log.Printf("[WARN] Uploading image %s (%d bytes). This can be pretty long.", d.Id(), fileSize) res := imagedata.Upload(imageClient, d.Id(), imgFile) if res.Err != nil { return fmt.Errorf("Error while uploading file %q: %s", imgFilePath, res.Err) } //wait for active stateConf := &resource.StateChangeConf{ Pending: []string{string(images.ImageStatusQueued), string(images.ImageStatusSaving)}, Target: []string{string(images.ImageStatusActive)}, Refresh: resourceImagesImageV2RefreshFunc(imageClient, d.Id(), fileSize, fileChecksum), Timeout: d.Timeout(schema.TimeoutCreate), Delay: 10 * time.Second, MinTimeout: 3 * time.Second, } if _, err = stateConf.WaitForState(); err != nil { return fmt.Errorf("Error waiting for Image: %s", err) } d.Partial(false) return resourceImagesImageV2Read(d, meta) } func resourceImagesImageV2Read(d *schema.ResourceData, meta interface{}) error { config := meta.(*Config) imageClient, err := config.imageV2Client(GetRegion(d)) if err != nil { return fmt.Errorf("Error creating OpenStack image client: %s", err) } img, err := images.Get(imageClient, d.Id()).Extract() if err != nil { return CheckDeleted(d, err, "image") } log.Printf("[DEBUG] Retrieved Image %s: %#v", d.Id(), img) d.Set("owner", img.Owner) d.Set("status", img.Status) d.Set("file", img.File) d.Set("schema", img.Schema) d.Set("checksum", img.Checksum) d.Set("size_bytes", img.SizeBytes) d.Set("metadata", img.Metadata) d.Set("created_at", img.CreatedAt) d.Set("update_at", img.UpdatedAt) d.Set("container_format", img.ContainerFormat) d.Set("disk_format", img.DiskFormat) d.Set("min_disk_gb", img.MinDiskGigabytes) d.Set("min_ram_mb", img.MinRAMMegabytes) d.Set("file", img.File) d.Set("name", img.Name) d.Set("protected", img.Protected) d.Set("size_bytes", img.SizeBytes) d.Set("tags", img.Tags) d.Set("visibility", img.Visibility) return nil } func resourceImagesImageV2Update(d *schema.ResourceData, meta interface{}) error { config := meta.(*Config) imageClient, err := config.imageV2Client(GetRegion(d)) if err != nil { return fmt.Errorf("Error creating OpenStack image client: %s", err) } updateOpts := make(images.UpdateOpts, 0) if d.HasChange("visibility") { visibility := resourceImagesImageV2VisibilityFromString(d.Get("visibility").(string)) v := images.UpdateVisibility{Visibility: visibility} updateOpts = append(updateOpts, v) } if d.HasChange("name") { v := images.ReplaceImageName{NewName: d.Get("name").(string)} updateOpts = append(updateOpts, v) } if d.HasChange("tags") { tags := d.Get("tags").(*schema.Set).List() v := images.ReplaceImageTags{ NewTags: resourceImagesImageV2BuildTags(tags), } updateOpts = append(updateOpts, v) } log.Printf("[DEBUG] Update Options: %#v", updateOpts) _, err = images.Update(imageClient, d.Id(), updateOpts).Extract() if err != nil { return fmt.Errorf("Error updating image: %s", err) } return resourceImagesImageV2Read(d, meta) } func resourceImagesImageV2Delete(d *schema.ResourceData, meta interface{}) error { config := meta.(*Config) imageClient, err := config.imageV2Client(GetRegion(d)) if err != nil { return fmt.Errorf("Error creating OpenStack image client: %s", err) } log.Printf("[DEBUG] Deleting Image %s", d.Id()) if err := images.Delete(imageClient, d.Id()).Err; err != nil { return fmt.Errorf("Error deleting Image: %s", err) } d.SetId("") return nil } func resourceImagesImageV2ValidateVisibility(v interface{}, k string) (ws []string, errors []error) { value := v.(string) validVisibilities := []string{ "public", "private", "shared", "community", } for _, v := range validVisibilities { if value == v { return } } err := fmt.Errorf("%s must be one of %s", k, validVisibilities) errors = append(errors, err) return } func validatePositiveInt(v interface{}, k string) (ws []string, errors []error) { value := v.(int) if value > 0 { return } errors = append(errors, fmt.Errorf("%q must be a positive integer", k)) return } var DiskFormats = [9]string{"ami", "ari", "aki", "vhd", "vmdk", "raw", "qcow2", "vdi", "iso"} func resourceImagesImageV2ValidateDiskFormat(v interface{}, k string) (ws []string, errors []error) { value := v.(string) for i := range DiskFormats { if value == DiskFormats[i] { return } } errors = append(errors, fmt.Errorf("%q must be one of %v", k, DiskFormats)) return } var ContainerFormats = [9]string{"ami", "ari", "aki", "bare", "ovf"} func resourceImagesImageV2ValidateContainerFormat(v interface{}, k string) (ws []string, errors []error) { value := v.(string) for i := range ContainerFormats { if value == ContainerFormats[i] { return } } errors = append(errors, fmt.Errorf("%q must be one of %v", k, ContainerFormats)) return } func resourceImagesImageV2VisibilityFromString(v string) images.ImageVisibility { switch v { case "public": return images.ImageVisibilityPublic case "private": return images.ImageVisibilityPrivate case "shared": return images.ImageVisibilityShared case "community": return images.ImageVisibilityCommunity } return "" } func fileMD5Checksum(f *os.File) (string, error) { hash := md5.New() if _, err := io.Copy(hash, f); err != nil { return "", err } return hex.EncodeToString(hash.Sum(nil)), nil } func resourceImagesImageV2FileProps(filename string) (int64, string, error) { var filesize int64 var filechecksum string file, err := os.Open(filename) if err != nil { return -1, "", fmt.Errorf("Error opening file for Image: %s", err) } defer file.Close() fstat, err := file.Stat() if err != nil { return -1, "", fmt.Errorf("Error reading image file %q: %s", file.Name(), err) } filesize = fstat.Size() filechecksum, err = fileMD5Checksum(file) if err != nil { return -1, "", fmt.Errorf("Error computing image file %q checksum: %s", file.Name(), err) } return filesize, filechecksum, nil } func resourceImagesImageV2File(d *schema.ResourceData) (string, error) { if filename := d.Get("local_file_path").(string); filename != "" { return filename, nil } else if furl := d.Get("image_source_url").(string); furl != "" { dir := d.Get("image_cache_path").(string) os.MkdirAll(dir, 0700) filename := filepath.Join(dir, fmt.Sprintf("%x.img", md5.Sum([]byte(furl)))) if _, err := os.Stat(filename); err != nil { if !os.IsNotExist(err) { return "", fmt.Errorf("Error while trying to access file %q: %s", filename, err) } log.Printf("[DEBUG] File doens't exists %s. will download from %s", filename, furl) file, err := os.Create(filename) if err != nil { return "", fmt.Errorf("Error creating file %q: %s", filename, err) } defer file.Close() resp, err := http.Get(furl) if err != nil { return "", fmt.Errorf("Error downloading image from %q", furl) } defer resp.Body.Close() if _, err = io.Copy(file, resp.Body); err != nil { return "", fmt.Errorf("Error downloading image %q to file %q: %s", furl, filename, err) } return filename, nil } else { log.Printf("[DEBUG] File exists %s", filename) return filename, nil } } else { return "", fmt.Errorf("Error in config. no file specified") } } func resourceImagesImageV2RefreshFunc(client *gophercloud.ServiceClient, id string, fileSize int64, checksum string) resource.StateRefreshFunc { return func() (interface{}, string, error) { img, err := images.Get(client, id).Extract() if err != nil { return nil, "", err } log.Printf("[DEBUG] OpenStack image status is: %s", img.Status) if img.Checksum != checksum || int64(img.SizeBytes) != fileSize { return img, fmt.Sprintf("%s", img.Status), fmt.Errorf("Error wrong size %v or checksum %q", img.SizeBytes, img.Checksum) } return img, fmt.Sprintf("%s", img.Status), nil } } func resourceImagesImageV2BuildTags(v []interface{}) []string { var tags []string for _, tag := range v { tags = append(tags, tag.(string)) } return tags }