github.com/andresvia/terraform@v0.6.15-0.20160412045437-d51c75946785/builtin/providers/aws/resource_aws_lambda_alias.go (about)

     1  package aws
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  
     7  	"github.com/aws/aws-sdk-go/aws"
     8  	"github.com/aws/aws-sdk-go/service/lambda"
     9  	"github.com/hashicorp/terraform/helper/schema"
    10  )
    11  
    12  func resourceAwsLambdaAlias() *schema.Resource {
    13  	return &schema.Resource{
    14  		Create: resourceAwsLambdaAliasCreate,
    15  		Read:   resourceAwsLambdaAliasRead,
    16  		Update: resourceAwsLambdaAliasUpdate,
    17  		Delete: resourceAwsLambdaAliasDelete,
    18  
    19  		Schema: map[string]*schema.Schema{
    20  			"description": &schema.Schema{
    21  				Type:     schema.TypeString,
    22  				Optional: true,
    23  			},
    24  			"function_name": &schema.Schema{
    25  				Type:     schema.TypeString,
    26  				Required: true,
    27  			},
    28  			"function_version": &schema.Schema{
    29  				Type:     schema.TypeString,
    30  				Required: true,
    31  			},
    32  			"name": &schema.Schema{
    33  				Type:     schema.TypeString,
    34  				Required: true,
    35  			},
    36  		},
    37  	}
    38  }
    39  
    40  // resourceAwsLambdaAliasCreate maps to:
    41  // CreateAlias in the API / SDK
    42  func resourceAwsLambdaAliasCreate(d *schema.ResourceData, meta interface{}) error {
    43  	conn := meta.(*AWSClient).lambdaconn
    44  
    45  	functionName := d.Get("function_name").(string)
    46  	aliasName := d.Get("name").(string)
    47  
    48  	log.Printf("[DEBUG] Creating Lambda alias: alias %s for function %s", aliasName, functionName)
    49  
    50  	params := &lambda.CreateAliasInput{
    51  		Description:     aws.String(d.Get("description").(string)),
    52  		FunctionName:    aws.String(functionName),
    53  		FunctionVersion: aws.String(d.Get("function_version").(string)),
    54  		Name:            aws.String(aliasName),
    55  	}
    56  
    57  	aliasConfiguration, err := conn.CreateAlias(params)
    58  	if err != nil {
    59  		return fmt.Errorf("Error creating Lambda alias: %s", err)
    60  	}
    61  
    62  	d.SetId(*aliasConfiguration.AliasArn)
    63  
    64  	return resourceAwsLambdaAliasRead(d, meta)
    65  }
    66  
    67  // resourceAwsLambdaAliasRead maps to:
    68  // GetAlias in the API / SDK
    69  func resourceAwsLambdaAliasRead(d *schema.ResourceData, meta interface{}) error {
    70  	conn := meta.(*AWSClient).lambdaconn
    71  
    72  	log.Printf("[DEBUG] Fetching Lambda alias: %s:%s", d.Get("function_name"), d.Get("name"))
    73  
    74  	params := &lambda.GetAliasInput{
    75  		FunctionName: aws.String(d.Get("function_name").(string)),
    76  		Name:         aws.String(d.Get("name").(string)),
    77  	}
    78  
    79  	aliasConfiguration, err := conn.GetAlias(params)
    80  	if err != nil {
    81  		return err
    82  	}
    83  
    84  	d.Set("description", aliasConfiguration.Description)
    85  	d.Set("function_version", aliasConfiguration.FunctionVersion)
    86  	d.Set("name", aliasConfiguration.Name)
    87  
    88  	return nil
    89  }
    90  
    91  // resourceAwsLambdaAliasDelete maps to:
    92  // DeleteAlias in the API / SDK
    93  func resourceAwsLambdaAliasDelete(d *schema.ResourceData, meta interface{}) error {
    94  	conn := meta.(*AWSClient).lambdaconn
    95  
    96  	log.Printf("[INFO] Deleting Lambda alias: %s:%s", d.Get("function_name"), d.Get("name"))
    97  
    98  	params := &lambda.DeleteAliasInput{
    99  		FunctionName: aws.String(d.Get("function_name").(string)),
   100  		Name:         aws.String(d.Get("name").(string)),
   101  	}
   102  
   103  	_, err := conn.DeleteAlias(params)
   104  	if err != nil {
   105  		return fmt.Errorf("Error deleting Lambda alias: %s", err)
   106  	}
   107  
   108  	d.SetId("")
   109  
   110  	return nil
   111  }
   112  
   113  // resourceAwsLambdaAliasUpdate maps to:
   114  // UpdateAlias in the API / SDK
   115  func resourceAwsLambdaAliasUpdate(d *schema.ResourceData, meta interface{}) error {
   116  	conn := meta.(*AWSClient).lambdaconn
   117  
   118  	log.Printf("[DEBUG] Updating Lambda alias: %s:%s", d.Get("function_name"), d.Get("name"))
   119  
   120  	params := &lambda.UpdateAliasInput{
   121  		Description:     aws.String(d.Get("description").(string)),
   122  		FunctionName:    aws.String(d.Get("function_name").(string)),
   123  		FunctionVersion: aws.String(d.Get("function_version").(string)),
   124  		Name:            aws.String(d.Get("name").(string)),
   125  	}
   126  
   127  	_, err := conn.UpdateAlias(params)
   128  	if err != nil {
   129  		return fmt.Errorf("Error updating Lambda alias: %s", err)
   130  	}
   131  
   132  	return nil
   133  }