github.com/gabrielperezs/terraform@v0.7.0-rc2.0.20160715084931-f7da2612946f/builtin/providers/aws/resource_aws_efs_file_system.go (about)

     1  package aws
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  	"time"
     7  
     8  	"github.com/aws/aws-sdk-go/aws"
     9  	"github.com/aws/aws-sdk-go/aws/awserr"
    10  	"github.com/aws/aws-sdk-go/service/efs"
    11  	"github.com/hashicorp/terraform/helper/resource"
    12  	"github.com/hashicorp/terraform/helper/schema"
    13  )
    14  
    15  func resourceAwsEfsFileSystem() *schema.Resource {
    16  	return &schema.Resource{
    17  		Create: resourceAwsEfsFileSystemCreate,
    18  		Read:   resourceAwsEfsFileSystemRead,
    19  		Update: resourceAwsEfsFileSystemUpdate,
    20  		Delete: resourceAwsEfsFileSystemDelete,
    21  
    22  		Importer: &schema.ResourceImporter{
    23  			State: schema.ImportStatePassthrough,
    24  		},
    25  
    26  		Schema: map[string]*schema.Schema{
    27  			"reference_name": &schema.Schema{
    28  				Type:     schema.TypeString,
    29  				Optional: true,
    30  				ForceNew: true,
    31  			},
    32  
    33  			"tags": tagsSchema(),
    34  		},
    35  	}
    36  }
    37  
    38  func resourceAwsEfsFileSystemCreate(d *schema.ResourceData, meta interface{}) error {
    39  	conn := meta.(*AWSClient).efsconn
    40  
    41  	referenceName := ""
    42  	if v, ok := d.GetOk("reference_name"); ok {
    43  		referenceName = v.(string) + "-"
    44  	}
    45  	token := referenceName + resource.UniqueId()
    46  	fs, err := conn.CreateFileSystem(&efs.CreateFileSystemInput{
    47  		CreationToken: aws.String(token),
    48  	})
    49  	if err != nil {
    50  		return err
    51  	}
    52  
    53  	log.Printf("[DEBUG] Creating EFS file system: %s", *fs)
    54  	d.SetId(*fs.FileSystemId)
    55  
    56  	stateConf := &resource.StateChangeConf{
    57  		Pending: []string{"creating"},
    58  		Target:  []string{"available"},
    59  		Refresh: func() (interface{}, string, error) {
    60  			resp, err := conn.DescribeFileSystems(&efs.DescribeFileSystemsInput{
    61  				FileSystemId: aws.String(d.Id()),
    62  			})
    63  			if err != nil {
    64  				return nil, "error", err
    65  			}
    66  
    67  			if len(resp.FileSystems) < 1 {
    68  				return nil, "not-found", fmt.Errorf("EFS file system %q not found", d.Id())
    69  			}
    70  
    71  			fs := resp.FileSystems[0]
    72  			log.Printf("[DEBUG] current status of %q: %q", *fs.FileSystemId, *fs.LifeCycleState)
    73  			return fs, *fs.LifeCycleState, nil
    74  		},
    75  		Timeout:    10 * time.Minute,
    76  		Delay:      2 * time.Second,
    77  		MinTimeout: 3 * time.Second,
    78  	}
    79  
    80  	_, err = stateConf.WaitForState()
    81  	if err != nil {
    82  		return fmt.Errorf("Error waiting for EFS file system (%q) to create: %q",
    83  			d.Id(), err.Error())
    84  	}
    85  	log.Printf("[DEBUG] EFS file system created: %q", *fs.FileSystemId)
    86  
    87  	return resourceAwsEfsFileSystemUpdate(d, meta)
    88  }
    89  
    90  func resourceAwsEfsFileSystemUpdate(d *schema.ResourceData, meta interface{}) error {
    91  	conn := meta.(*AWSClient).efsconn
    92  	err := setTagsEFS(conn, d)
    93  	if err != nil {
    94  		return err
    95  	}
    96  
    97  	return resourceAwsEfsFileSystemRead(d, meta)
    98  }
    99  
   100  func resourceAwsEfsFileSystemRead(d *schema.ResourceData, meta interface{}) error {
   101  	conn := meta.(*AWSClient).efsconn
   102  
   103  	resp, err := conn.DescribeFileSystems(&efs.DescribeFileSystemsInput{
   104  		FileSystemId: aws.String(d.Id()),
   105  	})
   106  	if err != nil {
   107  		if awsErr, ok := err.(awserr.Error); ok && awsErr.Code() == "FileSystemNotFound" {
   108  			log.Printf("[WARN] EFS File System (%s) not found, error code (404)", d.Id())
   109  			d.SetId("")
   110  			return nil
   111  		}
   112  		return err
   113  	}
   114  	if len(resp.FileSystems) < 1 {
   115  		return fmt.Errorf("EFS file system %q not found", d.Id())
   116  	}
   117  
   118  	tagsResp, err := conn.DescribeTags(&efs.DescribeTagsInput{
   119  		FileSystemId: aws.String(d.Id()),
   120  	})
   121  	if err != nil {
   122  		return err
   123  	}
   124  
   125  	d.Set("tags", tagsToMapEFS(tagsResp.Tags))
   126  
   127  	return nil
   128  }
   129  
   130  func resourceAwsEfsFileSystemDelete(d *schema.ResourceData, meta interface{}) error {
   131  	conn := meta.(*AWSClient).efsconn
   132  
   133  	log.Printf("[DEBUG] Deleting EFS file system %s", d.Id())
   134  	_, err := conn.DeleteFileSystem(&efs.DeleteFileSystemInput{
   135  		FileSystemId: aws.String(d.Id()),
   136  	})
   137  	stateConf := &resource.StateChangeConf{
   138  		Pending: []string{"available", "deleting"},
   139  		Target:  []string{},
   140  		Refresh: func() (interface{}, string, error) {
   141  			resp, err := conn.DescribeFileSystems(&efs.DescribeFileSystemsInput{
   142  				FileSystemId: aws.String(d.Id()),
   143  			})
   144  			if err != nil {
   145  				efsErr, ok := err.(awserr.Error)
   146  				if ok && efsErr.Code() == "FileSystemNotFound" {
   147  					return nil, "", nil
   148  				}
   149  				return nil, "error", err
   150  			}
   151  
   152  			if len(resp.FileSystems) < 1 {
   153  				return nil, "", nil
   154  			}
   155  
   156  			fs := resp.FileSystems[0]
   157  			log.Printf("[DEBUG] current status of %q: %q",
   158  				*fs.FileSystemId, *fs.LifeCycleState)
   159  			return fs, *fs.LifeCycleState, nil
   160  		},
   161  		Timeout:    10 * time.Minute,
   162  		Delay:      2 * time.Second,
   163  		MinTimeout: 3 * time.Second,
   164  	}
   165  
   166  	_, err = stateConf.WaitForState()
   167  	if err != nil {
   168  		return err
   169  	}
   170  
   171  	log.Printf("[DEBUG] EFS file system %q deleted.", d.Id())
   172  
   173  	return nil
   174  }