Merge pull request #596 from svanharmelen/f-refactor-aws-provider

provider/aws: refactor to use the schema.Provider approach

builtin/bins/provider-aws/main.go

@@ -3,13 +3,10 @@ package main
 import (
 	"github.com/hashicorp/terraform/builtin/providers/aws"
 	"github.com/hashicorp/terraform/plugin"
-	"github.com/hashicorp/terraform/terraform"
 )
 
 func main() {
 	plugin.Serve(&plugin.ServeOpts{
-		ProviderFunc: func() terraform.ResourceProvider {
+		ProviderFunc: aws.Provider,
-			return new(aws.ResourceProvider)
-		},
 	})
 }

builtin/providers/aws/config.go

@@ -2,17 +2,74 @@ package aws
 
 import (
 	"fmt"
-	"os"
+	"log"
 	"strings"
 	"unicode"
 
+	"github.com/hashicorp/terraform/helper/multierror"
+	"github.com/mitchellh/goamz/autoscaling"
 	"github.com/mitchellh/goamz/aws"
+	"github.com/mitchellh/goamz/ec2"
+	"github.com/mitchellh/goamz/elb"
+	"github.com/mitchellh/goamz/rds"
+	"github.com/mitchellh/goamz/route53"
+	"github.com/mitchellh/goamz/s3"
 )
 
 type Config struct {
-	AccessKey string `mapstructure:"access_key"`
+	AccessKey string
-	SecretKey string `mapstructure:"secret_key"`
+	SecretKey string
-	Region    string `mapstructure:"region"`
+	Region    string
+}
+
+type AWSClient struct {
+	ec2conn         *ec2.EC2
+	elbconn         *elb.ELB
+	autoscalingconn *autoscaling.AutoScaling
+	s3conn          *s3.S3
+	rdsconn         *rds.Rds
+	route53         *route53.Route53
+}
+
+// Client configures and returns a fully initailized AWSClient
+func (c *Config) Client() (interface{}, error) {
+	var client AWSClient
+
+	// Get the auth and region. This can fail if keys/regions were not
+	// specified and we're attempting to use the environment.
+	var errs []error
+	log.Println("[INFO] Building AWS auth structure")
+	auth, err := c.AWSAuth()
+	if err != nil {
+		errs = append(errs, err)
+	}
+
+	log.Println("[INFO] Building AWS region structure")
+	region, err := c.AWSRegion()
+	if err != nil {
+		errs = append(errs, err)
+	}
+
+	if len(errs) == 0 {
+		log.Println("[INFO] Initializing EC2 connection")
+		client.ec2conn = ec2.New(auth, region)
+		log.Println("[INFO] Initializing ELB connection")
+		client.elbconn = elb.New(auth, region)
+		log.Println("[INFO] Initializing AutoScaling connection")
+		client.autoscalingconn = autoscaling.New(auth, region)
+		log.Println("[INFO] Initializing S3 connection")
+		client.s3conn = s3.New(auth, region)
+		log.Println("[INFO] Initializing RDS connection")
+		client.rdsconn = rds.New(auth, region)
+		log.Println("[INFO] Initializing Route53 connection")
+		client.route53 = route53.New(auth, region)
+	}
+
+	if len(errs) > 0 {
+		return nil, &multierror.Error{Errors: errs}
+	}
+
+	return &client, nil
 }
 
 // AWSAuth returns a valid aws.Auth object for access to AWS services, or
@@ -56,10 +113,6 @@ func (c *Config) AWSRegion() (aws.Region, error) {
 		}
 	}
 
-	if v := os.Getenv("AWS_REGION"); v != "" {
-		return aws.Regions[v], nil
-	}
-
 	md, err := aws.GetMetaData("placement/availability-zone")
 	if err != nil {
 		return aws.Region{}, err

builtin/providers/aws/provider.go

@@ -4,28 +4,16 @@ import (
 	"os"
 
 	"github.com/hashicorp/terraform/helper/schema"
+	"github.com/hashicorp/terraform/terraform"
 )
 
-// Provider returns a schema.Provider for AWS.
+// Provider returns a terraform.ResourceProvider.
-//
+func Provider() terraform.ResourceProvider {
-// NOTE: schema.Provider became available long after the AWS provider
-// was started, so resources may not be converted to this new structure
-// yet. This is a WIP. To assist with the migration, make sure any resources
-// you migrate are acceptance tested, then perform the migration.
-func Provider() *schema.Provider {
 	// TODO: Move the validation to this, requires conditional schemas
 	// TODO: Move the configuration to this, requires validation
 
 	return &schema.Provider{
 		Schema: map[string]*schema.Schema{
-			"region": &schema.Schema{
-				Type:         schema.TypeString,
-				Required:     true,
-				DefaultFunc:  envDefaultFunc("AWS_REGION"),
-				Description:  descriptions["region"],
-				InputDefault: "us-east-1",
-			},
-
 			"access_key": &schema.Schema{
 				Type:        schema.TypeString,
 				Required:    true,
@@ -39,30 +27,38 @@ func Provider() *schema.Provider {
 				DefaultFunc: envDefaultFunc("AWS_SECRET_KEY"),
 				Description: descriptions["secret_key"],
 			},
+
+			"region": &schema.Schema{
+				Type:         schema.TypeString,
+				Required:     true,
+				DefaultFunc:  envDefaultFunc("AWS_REGION"),
+				Description:  descriptions["region"],
+				InputDefault: "us-east-1",
+			},
 		},
 
 		ResourcesMap: map[string]*schema.Resource{
 			"aws_autoscaling_group":       resourceAwsAutoscalingGroup(),
+			"aws_db_instance":             resourceAwsDbInstance(),
+			"aws_db_parameter_group":      resourceAwsDbParameterGroup(),
+			"aws_db_security_group":       resourceAwsDbSecurityGroup(),
+			"aws_db_subnet_group":         resourceAwsDbSubnetGroup(),
 			"aws_eip":                     resourceAwsEip(),
 			"aws_elb":                     resourceAwsElb(),
 			"aws_instance":                resourceAwsInstance(),
+			"aws_internet_gateway":        resourceAwsInternetGateway(),
 			"aws_launch_configuration":    resourceAwsLaunchConfiguration(),
+			"aws_route53_record":          resourceAwsRoute53Record(),
+			"aws_route53_zone":            resourceAwsRoute53Zone(),
+			"aws_route_table":             resourceAwsRouteTable(),
+			"aws_route_table_association": resourceAwsRouteTableAssociation(),
+			"aws_s3_bucket":               resourceAwsS3Bucket(),
 			"aws_security_group":          resourceAwsSecurityGroup(),
-			"aws_db_subnet_group":      resourceAwsDbSubnetGroup(),
-			"aws_vpc":                  resourceAwsVpc(),
-			"aws_db_parameter_group":   resourceAwsDbParameterGroup(),
 			"aws_subnet":                  resourceAwsSubnet(),
+			"aws_vpc":                     resourceAwsVpc(),
 		},
-	}
-}
 
-func envDefaultFunc(k string) schema.SchemaDefaultFunc {
+		ConfigureFunc: providerConfigure,
-	return func() (interface{}, error) {
-		if v := os.Getenv(k); v != "" {
-			return v, nil
-		}
-
-		return nil, nil
 	}
 }
 
@@ -80,3 +76,23 @@ func init() {
 			"from the 'Security & Credentials' section of the AWS console.",
 	}
 }
+
+func envDefaultFunc(k string) schema.SchemaDefaultFunc {
+	return func() (interface{}, error) {
+		if v := os.Getenv(k); v != "" {
+			return v, nil
+		}
+
+		return nil, nil
+	}
+}
+
+func providerConfigure(d *schema.ResourceData) (interface{}, error) {
+	config := Config{
+		AccessKey: d.Get("access_key").(string),
+		SecretKey: d.Get("secret_key").(string),
+		Region:    d.Get("region").(string),
+	}
+
+	return config.Client()
+}

builtin/providers/aws/provider_test.go

@@ -1,11 +1,43 @@
 package aws
 
 import (
+	"log"
+	"os"
 	"testing"
+
+	"github.com/hashicorp/terraform/helper/schema"
+	"github.com/hashicorp/terraform/terraform"
 )
 
+var testAccProviders map[string]terraform.ResourceProvider
+var testAccProvider *schema.Provider
+
+func init() {
+	testAccProvider = Provider().(*schema.Provider)
+	testAccProviders = map[string]terraform.ResourceProvider{
+		"aws": testAccProvider,
+	}
+}
+
 func TestProvider(t *testing.T) {
-	if err := Provider().InternalValidate(); err != nil {
+	if err := Provider().(*schema.Provider).InternalValidate(); err != nil {
 		t.Fatalf("err: %s", err)
 	}
 }
+
+func TestProvider_impl(t *testing.T) {
+	var _ terraform.ResourceProvider = Provider()
+}
+
+func testAccPreCheck(t *testing.T) {
+	if v := os.Getenv("AWS_ACCESS_KEY"); v == "" {
+		t.Fatal("AWS_ACCESS_KEY must be set for acceptance tests")
+	}
+	if v := os.Getenv("AWS_SECRET_KEY"); v == "" {
+		t.Fatal("AWS_SECRET_KEY must be set for acceptance tests")
+	}
+	if v := os.Getenv("AWS_REGION"); v == "" {
+		log.Println("[INFO] Test: Using us-west-2 as test region")
+		os.Setenv("AWS_REGION", "us-west-2")
+	}
+}

builtin/providers/aws/resource_aws_autoscaling_group.go

@@ -110,8 +110,7 @@ func resourceAwsAutoscalingGroup() *schema.Resource {
 }
 
 func resourceAwsAutoscalingGroupCreate(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	autoscalingconn := meta.(*AWSClient).autoscalingconn
-	autoscalingconn := p.autoscalingconn
 
 	var autoScalingGroupOpts autoscaling.CreateAutoScalingGroup
 	autoScalingGroupOpts.Name = d.Get("name").(string)
@@ -161,9 +160,32 @@ func resourceAwsAutoscalingGroupCreate(d *schema.ResourceData, meta interface{})
 	return resourceAwsAutoscalingGroupRead(d, meta)
 }
 
+func resourceAwsAutoscalingGroupRead(d *schema.ResourceData, meta interface{}) error {
+	g, err := getAwsAutoscalingGroup(d, meta)
+	if err != nil {
+		return err
+	}
+	if g == nil {
+		return nil
+	}
+
+	d.Set("availability_zones", g.AvailabilityZones)
+	d.Set("default_cooldown", g.DefaultCooldown)
+	d.Set("desired_capacity", g.DesiredCapacity)
+	d.Set("health_check_grace_period", g.HealthCheckGracePeriod)
+	d.Set("health_check_type", g.HealthCheckType)
+	d.Set("launch_configuration", g.LaunchConfigurationName)
+	d.Set("load_balancers", g.LoadBalancerNames)
+	d.Set("min_size", g.MinSize)
+	d.Set("max_size", g.MaxSize)
+	d.Set("name", g.Name)
+	d.Set("vpc_zone_identifier", g.VPCZoneIdentifier)
+
+	return nil
+}
+
 func resourceAwsAutoscalingGroupUpdate(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	autoscalingconn := meta.(*AWSClient).autoscalingconn
-	autoscalingconn := p.autoscalingconn
 
 	opts := autoscaling.UpdateAutoScalingGroup{
 		Name: d.Id(),
@@ -195,8 +217,7 @@ func resourceAwsAutoscalingGroupUpdate(d *schema.ResourceData, meta interface{})
 }
 
 func resourceAwsAutoscalingGroupDelete(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	autoscalingconn := meta.(*AWSClient).autoscalingconn
-	autoscalingconn := p.autoscalingconn
 
 	// Read the autoscaling group first. If it doesn't exist, we're done.
 	// We need the group in order to check if there are instances attached.
@@ -238,35 +259,10 @@ func resourceAwsAutoscalingGroupDelete(d *schema.ResourceData, meta interface{})
 	return nil
 }
 
-func resourceAwsAutoscalingGroupRead(d *schema.ResourceData, meta interface{}) error {
-	g, err := getAwsAutoscalingGroup(d, meta)
-	if err != nil {
-		return err
-	}
-	if g == nil {
-		return nil
-	}
-
-	d.Set("availability_zones", g.AvailabilityZones)
-	d.Set("default_cooldown", g.DefaultCooldown)
-	d.Set("desired_capacity", g.DesiredCapacity)
-	d.Set("health_check_grace_period", g.HealthCheckGracePeriod)
-	d.Set("health_check_type", g.HealthCheckType)
-	d.Set("launch_configuration", g.LaunchConfigurationName)
-	d.Set("load_balancers", g.LoadBalancerNames)
-	d.Set("min_size", g.MinSize)
-	d.Set("max_size", g.MaxSize)
-	d.Set("name", g.Name)
-	d.Set("vpc_zone_identifier", g.VPCZoneIdentifier)
-
-	return nil
-}
-
 func getAwsAutoscalingGroup(
 	d *schema.ResourceData,
 	meta interface{}) (*autoscaling.AutoScalingGroup, error) {
-	p := meta.(*ResourceProvider)
+	autoscalingconn := meta.(*AWSClient).autoscalingconn
-	autoscalingconn := p.autoscalingconn
 
 	describeOpts := autoscaling.DescribeAutoScalingGroups{
 		Names: []string{d.Id()},
@@ -298,8 +294,7 @@ func getAwsAutoscalingGroup(
 }
 
 func resourceAwsAutoscalingGroupDrain(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	autoscalingconn := meta.(*AWSClient).autoscalingconn
-	autoscalingconn := p.autoscalingconn
 
 	// First, set the capacity to zero so the group will drain
 	log.Printf("[DEBUG] Reducing autoscaling group capacity to zero")

builtin/providers/aws/resource_aws_autoscaling_group_test.go

@@ -72,7 +72,7 @@ func TestAccAWSAutoScalingGroupWithLoadBalancer(t *testing.T) {
 	})
 }
 func testAccCheckAWSAutoScalingGroupDestroy(s *terraform.State) error {
-	conn := testAccProvider.autoscalingconn
+	conn := testAccProvider.Meta().(*AWSClient).autoscalingconn
 
 	for _, rs := range s.RootModule().Resources {
 		if rs.Type != "aws_autoscaling_group" {
@@ -164,7 +164,7 @@ func testAccCheckAWSAutoScalingGroupExists(n string, group *autoscaling.AutoScal
 			return fmt.Errorf("No AutoScaling Group ID is set")
 		}
 
-		conn := testAccProvider.autoscalingconn
+		conn := testAccProvider.Meta().(*AWSClient).autoscalingconn
 
 		describeOpts := autoscaling.DescribeAutoScalingGroups{
 			Names: []string{rs.Primary.ID},

builtin/providers/aws/resource_aws_db_instance.go

@@ -3,116 +3,264 @@ package aws
 import (
 	"fmt"
 	"log"
-	"strconv"
 	"strings"
 	"time"
 
-	"github.com/hashicorp/terraform/flatmap"
+	"github.com/hashicorp/terraform/helper/hashcode"
-	"github.com/hashicorp/terraform/helper/config"
-	"github.com/hashicorp/terraform/helper/diff"
 	"github.com/hashicorp/terraform/helper/resource"
-	"github.com/hashicorp/terraform/terraform"
+	"github.com/hashicorp/terraform/helper/schema"
 	"github.com/mitchellh/goamz/rds"
 )
 
-func resource_aws_db_instance_create(
+func resourceAwsDbInstance() *schema.Resource {
-	s *terraform.InstanceState,
+	return &schema.Resource{
-	d *terraform.InstanceDiff,
+		Create: resourceAwsDbInstanceCreate,
-	meta interface{}) (*terraform.InstanceState, error) {
+		Read:   resourceAwsDbInstanceRead,
-	p := meta.(*ResourceProvider)
+		Delete: resourceAwsDbInstanceDelete,
-	conn := p.rdsconn
 
-	// Merge the diff into the state so that we have all the attributes
+		Schema: map[string]*schema.Schema{
-	// properly.
+			"name": &schema.Schema{
-	rs := s.MergeDiff(d)
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
 
-	var err error
+			"username": &schema.Schema{
-	var attr string
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
 
-	opts := rds.CreateDBInstance{}
+			"password": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
 
-	if attr = rs.Attributes["allocated_storage"]; attr != "" {
+			"engine": &schema.Schema{
-		opts.AllocatedStorage, err = strconv.Atoi(attr)
+				Type:     schema.TypeString,
-		opts.SetAllocatedStorage = true
+				Required: true,
+				ForceNew: true,
+			},
+
+			"engine_version": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"allocated_storage": &schema.Schema{
+				Type:     schema.TypeInt,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"identifier": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"instance_class": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"availability_zone": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				ForceNew: true,
+			},
+
+			"backup_retention_period": &schema.Schema{
+				Type:     schema.TypeInt,
+				Optional: true,
+				ForceNew: true,
+			},
+
+			"backup_window": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				ForceNew: true,
+			},
+
+			"iops": &schema.Schema{
+				Type:     schema.TypeInt,
+				Optional: true,
+				ForceNew: true,
+			},
+
+			"maintenance_window": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				ForceNew: true,
+			},
+
+			"multi_az": &schema.Schema{
+				Type:     schema.TypeBool,
+				Optional: true,
+				ForceNew: true,
+			},
+
+			"port": &schema.Schema{
+				Type:     schema.TypeInt,
+				Optional: true,
+				ForceNew: true,
+			},
+
+			"publicly_accessible": &schema.Schema{
+				Type:     schema.TypeBool,
+				Optional: true,
+				ForceNew: true,
+			},
+
+			"vpc_security_group_ids": &schema.Schema{
+				Type:     schema.TypeSet,
+				Optional: true,
+				Elem:     &schema.Schema{Type: schema.TypeString},
+				Set: func(v interface{}) int {
+					return hashcode.String(v.(string))
+				},
+			},
+
+			"security_group_names": &schema.Schema{
+				Type:     schema.TypeSet,
+				Optional: true,
+				Elem:     &schema.Schema{Type: schema.TypeString},
+				Set: func(v interface{}) int {
+					return hashcode.String(v.(string))
+				},
+			},
+
+			"skip_final_snapshot": &schema.Schema{
+				Type:     schema.TypeBool,
+				Optional: true,
+				ForceNew: true,
+			},
+
+			"final_snapshot_identifier": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				ForceNew: true,
+			},
+
+			"db_subnet_group_name": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				ForceNew: true,
+			},
+
+			"parameter_group_name": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				ForceNew: true,
+			},
+
+			"address": &schema.Schema{
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+
+			"endpoint": &schema.Schema{
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+
+			"status": &schema.Schema{
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+		},
+	}
 }
 
-	if attr = rs.Attributes["backup_retention_period"]; attr != "" {
+func resourceAwsDbInstanceCreate(d *schema.ResourceData, meta interface{}) error {
-		opts.BackupRetentionPeriod, err = strconv.Atoi(attr)
+	conn := meta.(*AWSClient).rdsconn
+	opts := rds.CreateDBInstance{
+		AllocatedStorage:     d.Get("allocated_storage").(int),
+		SetAllocatedStorage:  true,
+		DBInstanceClass:      d.Get("instance_class").(string),
+		DBInstanceIdentifier: d.Get("identifier").(string),
+		DBName:               d.Get("name").(string),
+		MasterUsername:       d.Get("username").(string),
+		MasterUserPassword:   d.Get("password").(string),
+		Engine:               d.Get("engine").(string),
+		EngineVersion:        d.Get("engine_version").(string),
+	}
+
+	// Special treatment for the password, as we don't want that
+	// saved into the state file
+	d.Set("password", "")
+
+	if attr, ok := d.GetOk("backup_retention_period"); ok {
+		opts.BackupRetentionPeriod = attr.(int)
 		opts.SetBackupRetentionPeriod = true
 	}
 
-	if attr = rs.Attributes["iops"]; attr != "" {
+	if attr, ok := d.GetOk("iops"); ok {
-		opts.Iops, err = strconv.Atoi(attr)
+		opts.Iops = attr.(int)
 		opts.SetIops = true
 	}
 
-	if attr = rs.Attributes["port"]; attr != "" {
+	if attr, ok := d.GetOk("port"); ok {
-		opts.Port, err = strconv.Atoi(attr)
+		opts.Port = attr.(int)
 		opts.SetPort = true
 	}
 
-	if attr = rs.Attributes["availability_zone"]; attr != "" {
+	if attr, ok := d.GetOk("multi_az"); ok {
-		opts.AvailabilityZone = attr
+		opts.MultiAZ = attr.(bool)
 	}
 
-	if attr = rs.Attributes["instance_class"]; attr != "" {
+	if attr, ok := d.GetOk("availability_zone"); ok {
-		opts.DBInstanceClass = attr
+		opts.AvailabilityZone = attr.(string)
 	}
 
-	if attr = rs.Attributes["maintenance_window"]; attr != "" {
+	if attr, ok := d.GetOk("maintenance_window"); ok {
-		opts.PreferredMaintenanceWindow = attr
+		opts.PreferredMaintenanceWindow = attr.(string)
 	}
 
-	if attr = rs.Attributes["backup_window"]; attr != "" {
+	if attr, ok := d.GetOk("backup_window"); ok {
-		opts.PreferredBackupWindow = attr
+		opts.PreferredBackupWindow = attr.(string)
 	}
 
-	if attr = rs.Attributes["multi_az"]; attr == "true" {
+	if attr, ok := d.GetOk("publicly_accessible"); ok {
-		opts.MultiAZ = true
+		opts.PubliclyAccessible = attr.(bool)
 	}
 
-	if attr = rs.Attributes["publicly_accessible"]; attr == "true" {
+	if attr, ok := d.GetOk("db_subnet_group_name"); ok {
-		opts.PubliclyAccessible = true
+		opts.DBSubnetGroupName = attr.(string)
 	}
 
-	if attr = rs.Attributes["db_subnet_group_name"]; attr != "" {
+	if attr, ok := d.GetOk("parameter_group_name"); ok {
-		opts.DBSubnetGroupName = attr
+		opts.DBParameterGroupName = attr.(string)
 	}
 
-	if attr = rs.Attributes["parameter_group_name"]; attr != "" {
+	if attr := d.Get("vpc_security_group_ids").(*schema.Set); attr.Len() > 0 {
-                opts.DBParameterGroupName = attr
+		var s []string
+		for _, v := range attr.List() {
+			s = append(s, v.(string))
+		}
+		opts.VpcSecurityGroupIds = s
 	}
 
-	if err != nil {
+	if attr := d.Get("security_group_names").(*schema.Set); attr.Len() > 0 {
-		return nil, fmt.Errorf("Error parsing configuration: %s", err)
+		var s []string
+		for _, v := range attr.List() {
+			s = append(s, v.(string))
 		}
-
+		opts.DBSecurityGroupNames = s
-	if _, ok := rs.Attributes["vpc_security_group_ids.#"]; ok {
-		opts.VpcSecurityGroupIds = expandStringList(flatmap.Expand(
-			rs.Attributes, "vpc_security_group_ids").([]interface{}))
 	}
 
-	if _, ok := rs.Attributes["security_group_names.#"]; ok {
-		opts.DBSecurityGroupNames = expandStringList(flatmap.Expand(
-			rs.Attributes, "security_group_names").([]interface{}))
-	}
-
-	opts.DBInstanceIdentifier = rs.Attributes["identifier"]
-	opts.DBName = rs.Attributes["name"]
-	opts.MasterUsername = rs.Attributes["username"]
-	opts.MasterUserPassword = rs.Attributes["password"]
-	opts.EngineVersion = rs.Attributes["engine_version"]
-	opts.Engine = rs.Attributes["engine"]
-
 	log.Printf("[DEBUG] DB Instance create configuration: %#v", opts)
-	_, err = conn.CreateDBInstance(&opts)
+	_, err := conn.CreateDBInstance(&opts)
 	if err != nil {
-		return nil, fmt.Errorf("Error creating DB Instance: %s", err)
+		return fmt.Errorf("Error creating DB Instance: %s", err)
 	}
 
-	rs.ID = rs.Attributes["identifier"]
+	d.SetId(d.Get("identifier").(string))
 
-	log.Printf("[INFO] DB Instance ID: %s", rs.ID)
+	log.Printf("[INFO] DB Instance ID: %s", d.Id())
 
 	log.Println(
 		"[INFO] Waiting for DB Instance to be available")
@@ -120,7 +268,7 @@ func resource_aws_db_instance_create(
 	stateConf := &resource.StateChangeConf{
 		Pending:    []string{"creating", "backing-up", "modifying"},
 		Target:     "available",
-		Refresh:    DBInstanceStateRefreshFunc(rs.ID, conn),
+		Refresh:    resourceAwsDbInstanceStateRefreshFunc(d, meta),
 		Timeout:    20 * time.Minute,
 		MinTimeout: 10 * time.Second,
 		Delay:      30 * time.Second, // Wait 30 secs before starting
@@ -129,38 +277,77 @@ func resource_aws_db_instance_create(
 	// Wait, catching any errors
 	_, err = stateConf.WaitForState()
 	if err != nil {
-		return rs, err
+		return err
 	}
 
-	v, err := resource_aws_db_instance_retrieve(rs.ID, conn)
+	return resourceAwsDbInstanceRead(d, meta)
+}
+
+func resourceAwsDbInstanceRead(d *schema.ResourceData, meta interface{}) error {
+	v, err := resourceAwsBbInstanceRetrieve(d, meta)
+
 	if err != nil {
-		return rs, err
+		return err
+	}
+	if v == nil {
+		d.SetId("")
+		return nil
 	}
 
-	return resource_aws_db_instance_update_state(rs, v)
+	d.Set("name", v.DBName)
+	d.Set("username", v.MasterUsername)
+	d.Set("engine", v.Engine)
+	d.Set("engine_version", v.EngineVersion)
+	d.Set("allocated_storage", v.AllocatedStorage)
+	d.Set("instance_class", v.DBInstanceClass)
+	d.Set("availability_zone", v.AvailabilityZone)
+	d.Set("backup_retention_period", v.BackupRetentionPeriod)
+	d.Set("backup_window", v.PreferredBackupWindow)
+	d.Set("maintenance_window", v.PreferredMaintenanceWindow)
+	d.Set("multi_az", v.MultiAZ)
+	d.Set("port", v.Port)
+	d.Set("db_subnet_group_name", v.DBSubnetGroup.Name)
+	d.Set("parameter_group_name", v.DBParameterGroupName)
+	d.Set("address", v.Address)
+	d.Set("endpoint", fmt.Sprintf("%s:%d", v.Address, v.Port))
+	d.Set("status", v.DBInstanceStatus)
+
+	// Create an empty schema.Set to hold all vpc security group ids
+	ids := &schema.Set{
+		F: func(v interface{}) int {
+			return hashcode.String(v.(string))
+		},
+	}
+	for _, v := range v.VpcSecurityGroupIds {
+		ids.Add(v)
+	}
+	d.Set("vpc_security_group_ids", ids)
+
+	// Create an empty schema.Set to hold all security group names
+	sgn := &schema.Set{
+		F: func(v interface{}) int {
+			return hashcode.String(v.(string))
+		},
+	}
+	for _, v := range v.DBSecurityGroupNames {
+		sgn.Add(v)
+	}
+	d.Set("security_group_names", sgn)
+
+	return nil
 }
 
-func resource_aws_db_instance_update(
+func resourceAwsDbInstanceDelete(d *schema.ResourceData, meta interface{}) error {
-	s *terraform.InstanceState,
+	conn := meta.(*AWSClient).rdsconn
-	d *terraform.InstanceDiff,
-	meta interface{}) (*terraform.InstanceState, error) {
-	panic("Cannot update DB")
-}
 
-func resource_aws_db_instance_destroy(
+	log.Printf("[DEBUG] DB Instance destroy: %v", d.Id())
-	s *terraform.InstanceState,
-	meta interface{}) error {
-	p := meta.(*ResourceProvider)
-	conn := p.rdsconn
 
-	log.Printf("[DEBUG] DB Instance destroy: %v", s.ID)
+	opts := rds.DeleteDBInstance{DBInstanceIdentifier: d.Id()}
 
-	opts := rds.DeleteDBInstance{DBInstanceIdentifier: s.ID}
+	if d.Get("skip_final_snapshot").(bool) {
-
-	if s.Attributes["skip_final_snapshot"] == "true" {
 		opts.SkipFinalSnapshot = true
 	} else {
-		opts.FinalDBSnapshotIdentifier = s.Attributes["final_snapshot_identifier"]
+		opts.FinalDBSnapshotIdentifier = d.Get("final_snapshot_identifier").(string)
 	}
 
 	log.Printf("[DEBUG] DB Instance destroy configuration: %v", opts)
@@ -174,7 +361,7 @@ func resource_aws_db_instance_destroy(
 		Pending: []string{"creating", "backing-up",
 			"modifying", "deleting", "available"},
 		Target:     "",
-		Refresh:    DBInstanceStateRefreshFunc(s.ID, conn),
+		Refresh:    resourceAwsDbInstanceStateRefreshFunc(d, meta),
 		Timeout:    20 * time.Minute,
 		MinTimeout: 10 * time.Second,
 		Delay:      30 * time.Second, // Wait 30 secs before starting
@@ -186,116 +373,12 @@ func resource_aws_db_instance_destroy(
 	return nil
 }
 
-func resource_aws_db_instance_refresh(
+func resourceAwsBbInstanceRetrieve(
-	s *terraform.InstanceState,
+	d *schema.ResourceData, meta interface{}) (*rds.DBInstance, error) {
-	meta interface{}) (*terraform.InstanceState, error) {
+	conn := meta.(*AWSClient).rdsconn
-	p := meta.(*ResourceProvider)
-	conn := p.rdsconn
 
-	v, err := resource_aws_db_instance_retrieve(s.ID, conn)
-
-	if err != nil {
-		return s, err
-	}
-	if v == nil {
-		s.ID = ""
-		return s, nil
-	}
-
-	return resource_aws_db_instance_update_state(s, v)
-}
-
-func resource_aws_db_instance_diff(
-	s *terraform.InstanceState,
-	c *terraform.ResourceConfig,
-	meta interface{}) (*terraform.InstanceDiff, error) {
-
-	b := &diff.ResourceBuilder{
-		Attrs: map[string]diff.AttrType{
-			"allocated_storage":         diff.AttrTypeCreate,
-			"availability_zone":         diff.AttrTypeCreate,
-			"backup_retention_period":   diff.AttrTypeCreate,
-			"backup_window":             diff.AttrTypeCreate,
-			"engine":                    diff.AttrTypeCreate,
-			"engine_version":            diff.AttrTypeCreate,
-			"identifier":                diff.AttrTypeCreate,
-			"instance_class":            diff.AttrTypeCreate,
-			"iops":                      diff.AttrTypeCreate,
-			"maintenance_window":        diff.AttrTypeCreate,
-			"multi_az":                  diff.AttrTypeCreate,
-			"name":                      diff.AttrTypeCreate,
-			"password":                  diff.AttrTypeCreate,
-			"port":                      diff.AttrTypeCreate,
-			"publicly_accessible":       diff.AttrTypeCreate,
-			"username":                  diff.AttrTypeCreate,
-			"vpc_security_group_ids":    diff.AttrTypeCreate,
-			"security_group_names":      diff.AttrTypeCreate,
-			"db_subnet_group_name":      diff.AttrTypeCreate,
-			"parameter_group_name":      diff.AttrTypeCreate,
-			"skip_final_snapshot":       diff.AttrTypeUpdate,
-			"final_snapshot_identifier": diff.AttrTypeUpdate,
-		},
-
-		ComputedAttrs: []string{
-			"address",
-			"availability_zone",
-			"backup_retention_period",
-			"backup_window",
-			"engine_version",
-			"maintenance_window",
-			"endpoint",
-			"status",
-			"multi_az",
-			"port",
-			"address",
-			"password",
-		},
-	}
-
-	return b.Diff(s, c)
-}
-
-func resource_aws_db_instance_update_state(
-	s *terraform.InstanceState,
-	v *rds.DBInstance) (*terraform.InstanceState, error) {
-
-	s.Attributes["address"] = v.Address
-	s.Attributes["allocated_storage"] = strconv.Itoa(v.AllocatedStorage)
-	s.Attributes["availability_zone"] = v.AvailabilityZone
-	s.Attributes["backup_retention_period"] = strconv.Itoa(v.BackupRetentionPeriod)
-	s.Attributes["backup_window"] = v.PreferredBackupWindow
-	s.Attributes["endpoint"] = fmt.Sprintf("%s:%s", s.Attributes["address"], strconv.Itoa(v.Port))
-	s.Attributes["engine"] = v.Engine
-	s.Attributes["engine_version"] = v.EngineVersion
-	s.Attributes["instance_class"] = v.DBInstanceClass
-	s.Attributes["maintenance_window"] = v.PreferredMaintenanceWindow
-	s.Attributes["multi_az"] = strconv.FormatBool(v.MultiAZ)
-	s.Attributes["name"] = v.DBName
-	s.Attributes["port"] = strconv.Itoa(v.Port)
-	s.Attributes["status"] = v.DBInstanceStatus
-	s.Attributes["username"] = v.MasterUsername
-	s.Attributes["db_subnet_group_name"] = v.DBSubnetGroup.Name
-	s.Attributes["parameter_group_name"] = v.DBParameterGroupName
-
-	// Flatten our group values
-	toFlatten := make(map[string]interface{})
-
-	if len(v.DBSecurityGroupNames) > 0 && v.DBSecurityGroupNames[0] != "" {
-		toFlatten["security_group_names"] = v.DBSecurityGroupNames
-	}
-	if len(v.VpcSecurityGroupIds) > 0 && v.VpcSecurityGroupIds[0] != "" {
-		toFlatten["vpc_security_group_ids"] = v.VpcSecurityGroupIds
-	}
-	for k, v := range flatmap.Flatten(toFlatten) {
-		s.Attributes[k] = v
-	}
-
-	return s, nil
-}
-
-func resource_aws_db_instance_retrieve(id string, conn *rds.Rds) (*rds.DBInstance, error) {
 	opts := rds.DescribeDBInstances{
-		DBInstanceIdentifier: id,
+		DBInstanceIdentifier: d.Id(),
 	}
 
 	log.Printf("[DEBUG] DB Instance describe configuration: %#v", opts)
@@ -310,7 +393,7 @@ func resource_aws_db_instance_retrieve(id string, conn *rds.Rds) (*rds.DBInstanc
 	}
 
 	if len(resp.DBInstances) != 1 ||
-		resp.DBInstances[0].DBInstanceIdentifier != id {
+		resp.DBInstances[0].DBInstanceIdentifier != d.Id() {
 		if err != nil {
 			return nil, nil
 		}
@@ -321,41 +404,10 @@ func resource_aws_db_instance_retrieve(id string, conn *rds.Rds) (*rds.DBInstanc
 	return &v, nil
 }
 
-func resource_aws_db_instance_validation() *config.Validator {
+func resourceAwsDbInstanceStateRefreshFunc(
-	return &config.Validator{
+	d *schema.ResourceData, meta interface{}) resource.StateRefreshFunc {
-		Required: []string{
-			"allocated_storage",
-			"engine",
-			"engine_version",
-			"identifier",
-			"instance_class",
-			"name",
-			"password",
-			"username",
-		},
-		Optional: []string{
-			"availability_zone",
-			"backup_retention_period",
-			"backup_window",
-			"iops",
-			"maintenance_window",
-			"multi_az",
-			"port",
-			"publicly_accessible",
-			"vpc_security_group_ids.*",
-			"skip_final_snapshot",
-			"security_group_names.*",
-			"db_subnet_group_name",
-			"parameter_group_name",
-			"skip_final_snapshot",
-			"final_snapshot_identifier",
-		},
-	}
-}
-
-func DBInstanceStateRefreshFunc(id string, conn *rds.Rds) resource.StateRefreshFunc {
 	return func() (interface{}, string, error) {
-		v, err := resource_aws_db_instance_retrieve(id, conn)
+		v, err := resourceAwsBbInstanceRetrieve(d, meta)
 
 		if err != nil {
 			log.Printf("Error on retrieving DB Instance when waiting: %s", err)

builtin/providers/aws/resource_aws_db_instance_test.go

@@ -52,7 +52,7 @@ func TestAccAWSDBInstance(t *testing.T) {
 }
 
 func testAccCheckAWSDBInstanceDestroy(s *terraform.State) error {
-	conn := testAccProvider.rdsconn
+	conn := testAccProvider.Meta().(*AWSClient).rdsconn
 
 	for _, rs := range s.RootModule().Resources {
 		if rs.Type != "aws_db_instance" {
@@ -115,7 +115,7 @@ func testAccCheckAWSDBInstanceExists(n string, v *rds.DBInstance) resource.TestC
 			return fmt.Errorf("No DB Instance ID is set")
 		}
 
-		conn := testAccProvider.rdsconn
+		conn := testAccProvider.Meta().(*AWSClient).rdsconn
 
 		opts := rds.DescribeDBInstances{
 			DBInstanceIdentifier: rs.Primary.ID,

builtin/providers/aws/resource_aws_db_parameter_group.go

@@ -56,18 +56,8 @@ func resourceAwsDbParameterGroup() *schema.Resource {
 	}
 }
 
-func resourceAwsDbParameterHash(v interface{}) int {
-	var buf bytes.Buffer
-	m := v.(map[string]interface{})
-	buf.WriteString(fmt.Sprintf("%s-", m["name"].(string)))
-	buf.WriteString(fmt.Sprintf("%s-", m["value"].(string)))
-
-	return hashcode.String(buf.String())
-}
-
 func resourceAwsDbParameterGroupCreate(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	rdsconn := meta.(*AWSClient).rdsconn
-	rdsconn := p.rdsconn
 
 	createOpts := rds.CreateDBParameterGroup{
 		DBParameterGroupName:   d.Get("name").(string),
@@ -93,9 +83,45 @@ func resourceAwsDbParameterGroupCreate(d *schema.ResourceData, meta interface{})
 	return resourceAwsDbParameterGroupUpdate(d, meta)
 }
 
+func resourceAwsDbParameterGroupRead(d *schema.ResourceData, meta interface{}) error {
+	rdsconn := meta.(*AWSClient).rdsconn
+
+	describeOpts := rds.DescribeDBParameterGroups{
+		DBParameterGroupName: d.Id(),
+	}
+
+	describeResp, err := rdsconn.DescribeDBParameterGroups(&describeOpts)
+	if err != nil {
+		return err
+	}
+
+	if len(describeResp.DBParameterGroups) != 1 ||
+		describeResp.DBParameterGroups[0].DBParameterGroupName != d.Id() {
+		return fmt.Errorf("Unable to find Parameter Group: %#v", describeResp.DBParameterGroups)
+	}
+
+	d.Set("name", describeResp.DBParameterGroups[0].DBParameterGroupName)
+	d.Set("family", describeResp.DBParameterGroups[0].DBParameterGroupFamily)
+	d.Set("description", describeResp.DBParameterGroups[0].Description)
+
+	// Only include user customized parameters as there's hundreds of system/default ones
+	describeParametersOpts := rds.DescribeDBParameters{
+		DBParameterGroupName: d.Id(),
+		Source:               "user",
+	}
+
+	describeParametersResp, err := rdsconn.DescribeDBParameters(&describeParametersOpts)
+	if err != nil {
+		return err
+	}
+
+	d.Set("parameter", flattenParameters(describeParametersResp.Parameters))
+
+	return nil
+}
+
 func resourceAwsDbParameterGroupUpdate(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	rdsconn := meta.(*AWSClient).rdsconn
-	rdsconn := p.rdsconn
 
 	d.Partial(true)
 
@@ -141,7 +167,7 @@ func resourceAwsDbParameterGroupDelete(d *schema.ResourceData, meta interface{})
 	stateConf := &resource.StateChangeConf{
 		Pending:    []string{"pending"},
 		Target:     "destroyed",
-		Refresh:    resourceDbParameterGroupDeleteRefreshFunc(d, meta),
+		Refresh:    resourceAwsDbParameterGroupDeleteRefreshFunc(d, meta),
 		Timeout:    3 * time.Minute,
 		MinTimeout: 1 * time.Second,
 	}
@@ -149,49 +175,10 @@ func resourceAwsDbParameterGroupDelete(d *schema.ResourceData, meta interface{})
 	return err
 }
 
-func resourceAwsDbParameterGroupRead(d *schema.ResourceData, meta interface{}) error {
+func resourceAwsDbParameterGroupDeleteRefreshFunc(
-	p := meta.(*ResourceProvider)
-	rdsconn := p.rdsconn
-
-	describeOpts := rds.DescribeDBParameterGroups{
-		DBParameterGroupName: d.Id(),
-	}
-
-	describeResp, err := rdsconn.DescribeDBParameterGroups(&describeOpts)
-	if err != nil {
-		return err
-	}
-
-	if len(describeResp.DBParameterGroups) != 1 ||
-		describeResp.DBParameterGroups[0].DBParameterGroupName != d.Id() {
-		return fmt.Errorf("Unable to find Parameter Group: %#v", describeResp.DBParameterGroups)
-	}
-
-	d.Set("name", describeResp.DBParameterGroups[0].DBParameterGroupName)
-	d.Set("family", describeResp.DBParameterGroups[0].DBParameterGroupFamily)
-	d.Set("description", describeResp.DBParameterGroups[0].Description)
-
-	// Only include user customized parameters as there's hundreds of system/default ones
-	describeParametersOpts := rds.DescribeDBParameters{
-		DBParameterGroupName: d.Id(),
-		Source:               "user",
-	}
-
-	describeParametersResp, err := rdsconn.DescribeDBParameters(&describeParametersOpts)
-	if err != nil {
-		return err
-	}
-
-	d.Set("parameter", flattenParameters(describeParametersResp.Parameters))
-
-	return nil
-}
-
-func resourceDbParameterGroupDeleteRefreshFunc(
 	d *schema.ResourceData,
 	meta interface{}) resource.StateRefreshFunc {
-	p := meta.(*ResourceProvider)
+	rdsconn := meta.(*AWSClient).rdsconn
-	rdsconn := p.rdsconn
 
 	return func() (interface{}, string, error) {
 
@@ -213,3 +200,12 @@ func resourceDbParameterGroupDeleteRefreshFunc(
 		return d, "destroyed", nil
 	}
 }
+
+func resourceAwsDbParameterHash(v interface{}) int {
+	var buf bytes.Buffer
+	m := v.(map[string]interface{})
+	buf.WriteString(fmt.Sprintf("%s-", m["name"].(string)))
+	buf.WriteString(fmt.Sprintf("%s-", m["value"].(string)))
+
+	return hashcode.String(buf.String())
+}

builtin/providers/aws/resource_aws_db_parameter_group_test.go

@@ -105,7 +105,7 @@ func TestAccAWSDBParameterGroupOnly(t *testing.T) {
 }
 
 func testAccCheckAWSDBParameterGroupDestroy(s *terraform.State) error {
-	conn := testAccProvider.rdsconn
+	conn := testAccProvider.Meta().(*AWSClient).rdsconn
 
 	for _, rs := range s.RootModule().Resources {
 		if rs.Type != "aws_db_parameter_group" {
@@ -168,7 +168,7 @@ func testAccCheckAWSDBParameterGroupExists(n string, v *rds.DBParameterGroup) re
 			return fmt.Errorf("No DB Parameter Group ID is set")
 		}
 
-		conn := testAccProvider.rdsconn
+		conn := testAccProvider.Meta().(*AWSClient).rdsconn
 
 		opts := rds.DescribeDBParameterGroups{
 			DBParameterGroupName: rs.Primary.ID,

builtin/providers/aws/resource_aws_db_security_group.go

@@ -1,59 +1,102 @@
 package aws
 
 import (
+	"bytes"
 	"fmt"
 	"log"
 	"time"
 
-	"github.com/hashicorp/terraform/flatmap"
+	"github.com/hashicorp/terraform/helper/hashcode"
-	"github.com/hashicorp/terraform/helper/config"
-	"github.com/hashicorp/terraform/helper/diff"
 	"github.com/hashicorp/terraform/helper/multierror"
 	"github.com/hashicorp/terraform/helper/resource"
-	"github.com/hashicorp/terraform/terraform"
+	"github.com/hashicorp/terraform/helper/schema"
 	"github.com/mitchellh/goamz/rds"
 )
 
-func resource_aws_db_security_group_create(
+func resourceAwsDbSecurityGroup() *schema.Resource {
-	s *terraform.InstanceState,
+	return &schema.Resource{
-	d *terraform.InstanceDiff,
+		Create: resourceAwsDbSecurityGroupCreate,
-	meta interface{}) (*terraform.InstanceState, error) {
+		Read:   resourceAwsDbSecurityGroupRead,
-	p := meta.(*ResourceProvider)
+		Delete: resourceAwsDbSecurityGroupDelete,
-	conn := p.rdsconn
 
-	// Merge the diff into the state so that we have all the attributes
+		Schema: map[string]*schema.Schema{
-	// properly.
+			"name": &schema.Schema{
-	rs := s.MergeDiff(d)
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"description": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"ingress": &schema.Schema{
+				Type:     schema.TypeSet,
+				Required: true,
+				ForceNew: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"cidr": &schema.Schema{
+							Type:     schema.TypeString,
+							Optional: true,
+						},
+
+						"security_group_name": &schema.Schema{
+							Type:     schema.TypeString,
+							Optional: true,
+							Computed: true,
+						},
+
+						"security_group_id": &schema.Schema{
+							Type:     schema.TypeString,
+							Optional: true,
+							Computed: true,
+						},
+
+						"security_group_owner_id": &schema.Schema{
+							Type:     schema.TypeString,
+							Optional: true,
+							Computed: true,
+						},
+					},
+				},
+				Set: resourceAwsDbSecurityGroupIngressHash,
+			},
+		},
+	}
+}
+
+func resourceAwsDbSecurityGroupCreate(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).rdsconn
 
 	var err error
 	var errs []error
 
 	opts := rds.CreateDBSecurityGroup{
-		DBSecurityGroupName:        rs.Attributes["name"],
+		DBSecurityGroupName:        d.Get("name").(string),
-		DBSecurityGroupDescription: rs.Attributes["description"],
+		DBSecurityGroupDescription: d.Get("description").(string),
 	}
 
 	log.Printf("[DEBUG] DB Security Group create configuration: %#v", opts)
 	_, err = conn.CreateDBSecurityGroup(&opts)
 	if err != nil {
-		return nil, fmt.Errorf("Error creating DB Security Group: %s", err)
+		return fmt.Errorf("Error creating DB Security Group: %s", err)
 	}
 
-	rs.ID = rs.Attributes["name"]
+	d.SetId(d.Get("name").(string))
 
-	log.Printf("[INFO] DB Security Group ID: %s", rs.ID)
+	log.Printf("[INFO] DB Security Group ID: %s", d.Id())
 
-	v, err := resource_aws_db_security_group_retrieve(rs.ID, conn)
+	sg, err := resourceAwsDbSecurityGroupRetrieve(d, meta)
 	if err != nil {
-		return rs, err
+		return err
 	}
 
-	if _, ok := rs.Attributes["ingress.#"]; ok {
+	ingresses := d.Get("ingress").(*schema.Set)
-		ingresses := flatmap.Expand(
+	for _, ing := range ingresses.List() {
-			rs.Attributes, "ingress").([]interface{})
+		err = resourceAwsDbSecurityGroupAuthorizeRule(ing, sg.Name, conn)
-
-		for _, ing := range ingresses {
-			err = authorize_ingress_rule(ing, v.Name, conn)
 
 		if err != nil {
 			errs = append(errs, err)
@@ -61,8 +104,7 @@ func resource_aws_db_security_group_create(
 	}
 
 	if len(errs) > 0 {
-			return rs, &multierror.Error{Errors: errs}
+		return &multierror.Error{Errors: errs}
-		}
 	}
 
 	log.Println(
@@ -71,35 +113,58 @@ func resource_aws_db_security_group_create(
 	stateConf := &resource.StateChangeConf{
 		Pending: []string{"authorizing"},
 		Target:  "authorized",
-		Refresh: DBSecurityGroupStateRefreshFunc(rs.ID, conn),
+		Refresh: resourceAwsDbSecurityGroupStateRefreshFunc(d, meta),
 		Timeout: 10 * time.Minute,
 	}
 
 	// Wait, catching any errors
 	_, err = stateConf.WaitForState()
 	if err != nil {
-		return rs, err
+		return err
 	}
 
-	return resource_aws_db_security_group_update_state(rs, v)
+	return resourceAwsDbSecurityGroupRead(d, meta)
 }
 
-func resource_aws_db_security_group_update(
+func resourceAwsDbSecurityGroupRead(d *schema.ResourceData, meta interface{}) error {
-	s *terraform.InstanceState,
+	sg, err := resourceAwsDbSecurityGroupRetrieve(d, meta)
-	d *terraform.InstanceDiff,
+	if err != nil {
-	meta interface{}) (*terraform.InstanceState, error) {
+		return err
-	panic("Cannot update DB security group")
 	}
 
-func resource_aws_db_security_group_destroy(
+	d.Set("name", sg.Name)
-	s *terraform.InstanceState,
+	d.Set("description", sg.Description)
-	meta interface{}) error {
-	p := meta.(*ResourceProvider)
-	conn := p.rdsconn
 
-	log.Printf("[DEBUG] DB Security Group destroy: %v", s.ID)
+	// Create an empty schema.Set to hold all ingress rules
+	rules := &schema.Set{
+		F: resourceAwsDbSecurityGroupIngressHash,
+	}
 
-	opts := rds.DeleteDBSecurityGroup{DBSecurityGroupName: s.ID}
+	for _, v := range sg.CidrIps {
+		rule := map[string]interface{}{"cidr": v}
+		rules.Add(rule)
+	}
+
+	for i, _ := range sg.EC2SecurityGroupOwnerIds {
+		rule := map[string]interface{}{
+			"security_group_name":     sg.EC2SecurityGroupNames[i],
+			"security_group_id":       sg.EC2SecurityGroupIds[i],
+			"security_group_owner_id": sg.EC2SecurityGroupOwnerIds[i],
+		}
+		rules.Add(rule)
+	}
+
+	d.Set("ingress", rules)
+
+	return nil
+}
+
+func resourceAwsDbSecurityGroupDelete(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).rdsconn
+
+	log.Printf("[DEBUG] DB Security Group destroy: %v", d.Id())
+
+	opts := rds.DeleteDBSecurityGroup{DBSecurityGroupName: d.Id()}
 
 	log.Printf("[DEBUG] DB Security Group destroy configuration: %v", opts)
 	_, err := conn.DeleteDBSecurityGroup(&opts)
@@ -115,70 +180,11 @@ func resource_aws_db_security_group_destroy(
 	return nil
 }
 
-func resource_aws_db_security_group_refresh(
+func resourceAwsDbSecurityGroupRetrieve(d *schema.ResourceData, meta interface{}) (*rds.DBSecurityGroup, error) {
-	s *terraform.InstanceState,
+	conn := meta.(*AWSClient).rdsconn
-	meta interface{}) (*terraform.InstanceState, error) {
-	p := meta.(*ResourceProvider)
-	conn := p.rdsconn
 
-	v, err := resource_aws_db_security_group_retrieve(s.ID, conn)
-
-	if err != nil {
-		return s, err
-	}
-
-	return resource_aws_db_security_group_update_state(s, v)
-}
-
-func resource_aws_db_security_group_diff(
-	s *terraform.InstanceState,
-	c *terraform.ResourceConfig,
-	meta interface{}) (*terraform.InstanceDiff, error) {
-
-	b := &diff.ResourceBuilder{
-		Attrs: map[string]diff.AttrType{
-			"name":        diff.AttrTypeCreate,
-			"description": diff.AttrTypeCreate,
-			"ingress":     diff.AttrTypeCreate,
-		},
-
-		ComputedAttrs: []string{
-			"ingress_cidr",
-			"ingress_security_groups",
-		},
-	}
-
-	return b.Diff(s, c)
-}
-
-func resource_aws_db_security_group_update_state(
-	s *terraform.InstanceState,
-	v *rds.DBSecurityGroup) (*terraform.InstanceState, error) {
-
-	s.Attributes["name"] = v.Name
-	s.Attributes["description"] = v.Description
-
-	// Flatten our group values
-	toFlatten := make(map[string]interface{})
-
-	if len(v.EC2SecurityGroupOwnerIds) > 0 && v.EC2SecurityGroupOwnerIds[0] != "" {
-		toFlatten["ingress_security_groups"] = v.EC2SecurityGroupOwnerIds
-	}
-
-	if len(v.CidrIps) > 0 && v.CidrIps[0] != "" {
-		toFlatten["ingress_cidr"] = v.CidrIps
-	}
-
-	for k, v := range flatmap.Flatten(toFlatten) {
-		s.Attributes[k] = v
-	}
-
-	return s, nil
-}
-
-func resource_aws_db_security_group_retrieve(id string, conn *rds.Rds) (*rds.DBSecurityGroup, error) {
 	opts := rds.DescribeDBSecurityGroups{
-		DBSecurityGroupName: id,
+		DBSecurityGroupName: d.Id(),
 	}
 
 	log.Printf("[DEBUG] DB Security Group describe configuration: %#v", opts)
@@ -190,7 +196,7 @@ func resource_aws_db_security_group_retrieve(id string, conn *rds.Rds) (*rds.DBS
 	}
 
 	if len(resp.DBSecurityGroups) != 1 ||
-		resp.DBSecurityGroups[0].Name != id {
+		resp.DBSecurityGroups[0].Name != d.Id() {
 		if err != nil {
 			return nil, fmt.Errorf("Unable to find DB Security Group: %#v", resp.DBSecurityGroups)
 		}
@@ -202,27 +208,27 @@ func resource_aws_db_security_group_retrieve(id string, conn *rds.Rds) (*rds.DBS
 }
 
 // Authorizes the ingress rule on the db security group
-func authorize_ingress_rule(ingress interface{}, dbSecurityGroupName string, conn *rds.Rds) error {
+func resourceAwsDbSecurityGroupAuthorizeRule(ingress interface{}, dbSecurityGroupName string, conn *rds.Rds) error {
 	ing := ingress.(map[string]interface{})
 
 	opts := rds.AuthorizeDBSecurityGroupIngress{
 		DBSecurityGroupName: dbSecurityGroupName,
 	}
 
-	if attr, ok := ing["cidr"].(string); ok && attr != "" {
+	if attr, ok := ing["cidr"]; ok && attr != "" {
-		opts.Cidr = attr
+		opts.Cidr = attr.(string)
 	}
 
-	if attr, ok := ing["security_group_name"].(string); ok && attr != "" {
+	if attr, ok := ing["security_group_name"]; ok && attr != "" {
-		opts.EC2SecurityGroupName = attr
+		opts.EC2SecurityGroupName = attr.(string)
 	}
 
-	if attr, ok := ing["security_group_id"].(string); ok && attr != "" {
+	if attr, ok := ing["security_group_id"]; ok && attr != "" {
-		opts.EC2SecurityGroupId = attr
+		opts.EC2SecurityGroupId = attr.(string)
 	}
 
-	if attr, ok := ing["security_group_owner_id"].(string); ok && attr != "" {
+	if attr, ok := ing["security_group_owner_id"]; ok && attr != "" {
-		opts.EC2SecurityGroupOwnerId = attr
+		opts.EC2SecurityGroupOwnerId = attr.(string)
 	}
 
 	log.Printf("[DEBUG] Authorize ingress rule configuration: %#v", opts)
@@ -236,25 +242,33 @@ func authorize_ingress_rule(ingress interface{}, dbSecurityGroupName string, con
 	return nil
 }
 
-func resource_aws_db_security_group_validation() *config.Validator {
+func resourceAwsDbSecurityGroupIngressHash(v interface{}) int {
-	return &config.Validator{
+	var buf bytes.Buffer
-		Required: []string{
+	m := v.(map[string]interface{})
-			"name",
+
-			"description",
+	if v, ok := m["cidr"]; ok {
-		},
+		buf.WriteString(fmt.Sprintf("%s-", v.(string)))
-		Optional: []string{
-			"ingress.*",
-			"ingress.*.cidr",
-			"ingress.*.security_group_name",
-			"ingress.*.security_group_id",
-			"ingress.*.security_group_owner_id",
-		},
-	}
 	}
 
-func DBSecurityGroupStateRefreshFunc(id string, conn *rds.Rds) resource.StateRefreshFunc {
+	if v, ok := m["security_group_name"]; ok {
+		buf.WriteString(fmt.Sprintf("%s-", v.(string)))
+	}
+
+	if v, ok := m["security_group_id"]; ok {
+		buf.WriteString(fmt.Sprintf("%s-", v.(string)))
+	}
+
+	if v, ok := m["security_group_owner_id"]; ok {
+		buf.WriteString(fmt.Sprintf("%s-", v.(string)))
+	}
+
+	return hashcode.String(buf.String())
+}
+
+func resourceAwsDbSecurityGroupStateRefreshFunc(
+	d *schema.ResourceData, meta interface{}) resource.StateRefreshFunc {
 	return func() (interface{}, string, error) {
-		v, err := resource_aws_db_security_group_retrieve(id, conn)
+		v, err := resourceAwsDbSecurityGroupRetrieve(d, meta)
 
 		if err != nil {
 			log.Printf("Error on retrieving DB Security Group when waiting: %s", err)

builtin/providers/aws/resource_aws_db_security_group_test.go

@@ -37,7 +37,7 @@ func TestAccAWSDBSecurityGroup(t *testing.T) {
 }
 
 func testAccCheckAWSDBSecurityGroupDestroy(s *terraform.State) error {
-	conn := testAccProvider.rdsconn
+	conn := testAccProvider.Meta().(*AWSClient).rdsconn
 
 	for _, rs := range s.RootModule().Resources {
 		if rs.Type != "aws_db_security_group" {
@@ -107,7 +107,7 @@ func testAccCheckAWSDBSecurityGroupExists(n string, v *rds.DBSecurityGroup) reso
 			return fmt.Errorf("No DB Security Group ID is set")
 		}
 
-		conn := testAccProvider.rdsconn
+		conn := testAccProvider.Meta().(*AWSClient).rdsconn
 
 		opts := rds.DescribeDBSecurityGroups{
 			DBSecurityGroupName: rs.Primary.ID,

builtin/providers/aws/resource_aws_db_subnet_group.go

@@ -15,7 +15,6 @@ func resourceAwsDbSubnetGroup() *schema.Resource {
 	return &schema.Resource{
 		Create: resourceAwsDbSubnetGroupCreate,
 		Read:   resourceAwsDbSubnetGroupRead,
-		Update: nil,
 		Delete: resourceAwsDbSubnetGroupDelete,
 
 		Schema: map[string]*schema.Schema{
@@ -45,8 +44,7 @@ func resourceAwsDbSubnetGroup() *schema.Resource {
 }
 
 func resourceAwsDbSubnetGroupCreate(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	rdsconn := meta.(*AWSClient).rdsconn
-	rdsconn := p.rdsconn
 
 	subnetIdsSet := d.Get("subnet_ids").(*schema.Set)
 	subnetIds := make([]string, subnetIdsSet.Len())
@@ -71,21 +69,8 @@ func resourceAwsDbSubnetGroupCreate(d *schema.ResourceData, meta interface{}) er
 	return resourceAwsDbSubnetGroupRead(d, meta)
 }
 
-func resourceAwsDbSubnetGroupDelete(d *schema.ResourceData, meta interface{}) error {
-	stateConf := &resource.StateChangeConf{
-		Pending:    []string{"pending"},
-		Target:     "destroyed",
-		Refresh:    resourceDbSubnetGroupDeleteRefreshFunc(d, meta),
-		Timeout:    3 * time.Minute,
-		MinTimeout: 1 * time.Second,
-	}
-	_, err := stateConf.WaitForState()
-	return err
-}
-
 func resourceAwsDbSubnetGroupRead(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	rdsconn := meta.(*AWSClient).rdsconn
-	rdsconn := p.rdsconn
 
 	describeOpts := rds.DescribeDBSubnetGroups{
 		DBSubnetGroupName: d.Id(),
@@ -107,11 +92,22 @@ func resourceAwsDbSubnetGroupRead(d *schema.ResourceData, meta interface{}) erro
 	return nil
 }
 
-func resourceDbSubnetGroupDeleteRefreshFunc(
+func resourceAwsDbSubnetGroupDelete(d *schema.ResourceData, meta interface{}) error {
+	stateConf := &resource.StateChangeConf{
+		Pending:    []string{"pending"},
+		Target:     "destroyed",
+		Refresh:    resourceAwsDbSubnetGroupDeleteRefreshFunc(d, meta),
+		Timeout:    3 * time.Minute,
+		MinTimeout: 1 * time.Second,
+	}
+	_, err := stateConf.WaitForState()
+	return err
+}
+
+func resourceAwsDbSubnetGroupDeleteRefreshFunc(
 	d *schema.ResourceData,
 	meta interface{}) resource.StateRefreshFunc {
-	p := meta.(*ResourceProvider)
+	rdsconn := meta.(*AWSClient).rdsconn
-	rdsconn := p.rdsconn
 
 	return func() (interface{}, string, error) {
 

builtin/providers/aws/resource_aws_db_subnet_group_test.go

@@ -9,7 +9,7 @@ import (
 	"github.com/mitchellh/goamz/rds"
 )
 
-func TestAccAWSDbSubnetGroup(t *testing.T) {
+func TestAccAWSDBSubnetGroup(t *testing.T) {
 	var v rds.DBSubnetGroup
 
 	testCheck := func(*terraform.State) error {
@@ -19,12 +19,12 @@ func TestAccAWSDbSubnetGroup(t *testing.T) {
 	resource.Test(t, resource.TestCase{
 		PreCheck:     func() { testAccPreCheck(t) },
 		Providers:    testAccProviders,
-		CheckDestroy: testAccCheckDbSubnetGroupDestroy,
+		CheckDestroy: testAccCheckDBSubnetGroupDestroy,
 		Steps: []resource.TestStep{
 			resource.TestStep{
-				Config: testAccDbSubnetGroupConfig,
+				Config: testAccDBSubnetGroupConfig,
 				Check: resource.ComposeTestCheckFunc(
-					testAccCheckDbSubnetGroupExists(
+					testAccCheckDBSubnetGroupExists(
 						"aws_db_subnet_group.foo", &v),
 					testCheck,
 				),
@@ -33,8 +33,8 @@ func TestAccAWSDbSubnetGroup(t *testing.T) {
 	})
 }
 
-func testAccCheckDbSubnetGroupDestroy(s *terraform.State) error {
+func testAccCheckDBSubnetGroupDestroy(s *terraform.State) error {
-	conn := testAccProvider.rdsconn
+	conn := testAccProvider.Meta().(*AWSClient).rdsconn
 
 	for _, rs := range s.RootModule().Resources {
 		if rs.Type != "aws_db_subnet_group" {
@@ -64,7 +64,7 @@ func testAccCheckDbSubnetGroupDestroy(s *terraform.State) error {
 	return nil
 }
 
-func testAccCheckDbSubnetGroupExists(n string, v *rds.DBSubnetGroup) resource.TestCheckFunc {
+func testAccCheckDBSubnetGroupExists(n string, v *rds.DBSubnetGroup) resource.TestCheckFunc {
 	return func(s *terraform.State) error {
 		rs, ok := s.RootModule().Resources[n]
 		if !ok {
@@ -75,7 +75,7 @@ func testAccCheckDbSubnetGroupExists(n string, v *rds.DBSubnetGroup) resource.Te
 			return fmt.Errorf("No ID is set")
 		}
 
-		conn := testAccProvider.rdsconn
+		conn := testAccProvider.Meta().(*AWSClient).rdsconn
 		resp, err := conn.DescribeDBSubnetGroups(&rds.DescribeDBSubnetGroups{rs.Primary.ID})
 		if err != nil {
 			return err
@@ -90,18 +90,20 @@ func testAccCheckDbSubnetGroupExists(n string, v *rds.DBSubnetGroup) resource.Te
 	}
 }
 
-const testAccDbSubnetGroupConfig = `
+const testAccDBSubnetGroupConfig = `
 resource "aws_vpc" "foo" {
 	cidr_block = "10.1.0.0/16"
 }
 
 resource "aws_subnet" "foo" {
 	cidr_block = "10.1.1.0/24"
+	availability_zone = "us-west-2a"
 	vpc_id = "${aws_vpc.foo.id}"
 }
 
 resource "aws_subnet" "bar" {
 	cidr_block = "10.1.2.0/24"
+	availability_zone = "us-west-2b"
 	vpc_id = "${aws_vpc.foo.id}"
 }
 

builtin/providers/aws/resource_aws_eip.go

@@ -8,7 +8,6 @@ import (
 
 	"github.com/hashicorp/terraform/helper/resource"
 	"github.com/hashicorp/terraform/helper/schema"
-	//"github.com/hashicorp/terraform/terraform"
 	"github.com/mitchellh/goamz/ec2"
 )
 
@@ -60,8 +59,7 @@ func resourceAwsEip() *schema.Resource {
 }
 
 func resourceAwsEipCreate(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	ec2conn := meta.(*AWSClient).ec2conn
-	ec2conn := p.ec2conn
 
 	// By default, we're not in a VPC
 	domainOpt := ""
@@ -97,9 +95,55 @@ func resourceAwsEipCreate(d *schema.ResourceData, meta interface{}) error {
 	return resourceAwsEipUpdate(d, meta)
 }
 
+func resourceAwsEipRead(d *schema.ResourceData, meta interface{}) error {
+	ec2conn := meta.(*AWSClient).ec2conn
+
+	domain := resourceAwsEipDomain(d)
+	id := d.Id()
+
+	assocIds := []string{}
+	publicIps := []string{}
+	if domain == "vpc" {
+		assocIds = []string{id}
+	} else {
+		publicIps = []string{id}
+	}
+
+	log.Printf(
+		"[DEBUG] EIP describe configuration: %#v, %#v (domain: %s)",
+		assocIds, publicIps, domain)
+
+	describeAddresses, err := ec2conn.Addresses(publicIps, assocIds, nil)
+	if err != nil {
+		if ec2err, ok := err.(*ec2.Error); ok && ec2err.Code == "InvalidAllocationID.NotFound" {
+			d.SetId("")
+			return nil
+		}
+
+		return fmt.Errorf("Error retrieving EIP: %s", err)
+	}
+
+	// Verify AWS returned our EIP
+	if len(describeAddresses.Addresses) != 1 ||
+		describeAddresses.Addresses[0].AllocationId != id ||
+		describeAddresses.Addresses[0].PublicIp != id {
+		if err != nil {
+			return fmt.Errorf("Unable to find EIP: %#v", describeAddresses.Addresses)
+		}
+	}
+
+	address := describeAddresses.Addresses[0]
+
+	d.Set("association_id", address.AssociationId)
+	d.Set("instance", address.InstanceId)
+	d.Set("public_ip", address.PublicIp)
+	d.Set("private_ip", address.PrivateIpAddress)
+
+	return nil
+}
+
 func resourceAwsEipUpdate(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	ec2conn := meta.(*AWSClient).ec2conn
-	ec2conn := p.ec2conn
 
 	domain := resourceAwsEipDomain(d)
 
@@ -132,8 +176,7 @@ func resourceAwsEipUpdate(d *schema.ResourceData, meta interface{}) error {
 }
 
 func resourceAwsEipDelete(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	ec2conn := meta.(*AWSClient).ec2conn
-	ec2conn := p.ec2conn
 
 	if err := resourceAwsEipRead(d, meta); err != nil {
 		return err
@@ -183,54 +226,6 @@ func resourceAwsEipDelete(d *schema.ResourceData, meta interface{}) error {
 	})
 }
 
-func resourceAwsEipRead(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
-	ec2conn := p.ec2conn
-
-	domain := resourceAwsEipDomain(d)
-	id := d.Id()
-
-	assocIds := []string{}
-	publicIps := []string{}
-	if domain == "vpc" {
-		assocIds = []string{id}
-	} else {
-		publicIps = []string{id}
-	}
-
-	log.Printf(
-		"[DEBUG] EIP describe configuration: %#v, %#v (domain: %s)",
-		assocIds, publicIps, domain)
-
-	describeAddresses, err := ec2conn.Addresses(publicIps, assocIds, nil)
-	if err != nil {
-		if ec2err, ok := err.(*ec2.Error); ok && ec2err.Code == "InvalidAllocationID.NotFound" {
-			d.SetId("")
-			return nil
-		}
-
-		return fmt.Errorf("Error retrieving EIP: %s", err)
-	}
-
-	// Verify AWS returned our EIP
-	if len(describeAddresses.Addresses) != 1 ||
-		describeAddresses.Addresses[0].AllocationId != id ||
-		describeAddresses.Addresses[0].PublicIp != id {
-		if err != nil {
-			return fmt.Errorf("Unable to find EIP: %#v", describeAddresses.Addresses)
-		}
-	}
-
-	address := describeAddresses.Addresses[0]
-
-	d.Set("association_id", address.AssociationId)
-	d.Set("instance", address.InstanceId)
-	d.Set("public_ip", address.PublicIp)
-	d.Set("private_ip", address.PrivateIpAddress)
-
-	return nil
-}
-
 func resourceAwsEipDomain(d *schema.ResourceData) string {
 	if v, ok := d.GetOk("domain"); ok {
 		return v.(string)

builtin/providers/aws/resource_aws_eip_test.go

@@ -57,7 +57,7 @@ func TestAccAWSEIP_instance(t *testing.T) {
 }
 
 func testAccCheckAWSEIPDestroy(s *terraform.State) error {
-	conn := testAccProvider.ec2conn
+	conn := testAccProvider.Meta().(*AWSClient).ec2conn
 
 	for _, rs := range s.RootModule().Resources {
 		if rs.Type != "aws_eip" {
@@ -112,7 +112,7 @@ func testAccCheckAWSEIPExists(n string, res *ec2.Address) resource.TestCheckFunc
 			return fmt.Errorf("No EIP ID is set")
 		}
 
-		conn := testAccProvider.ec2conn
+		conn := testAccProvider.Meta().(*AWSClient).ec2conn
 
 		if strings.Contains(rs.Primary.ID, "eipalloc") {
 			describe, err := conn.Addresses([]string{}, []string{rs.Primary.ID}, nil)

builtin/providers/aws/resource_aws_elb.go

@@ -150,36 +150,8 @@ func resourceAwsElb() *schema.Resource {
 	}
 }
 
-func resourceAwsElbHealthCheckHash(v interface{}) int {
-	var buf bytes.Buffer
-	m := v.(map[string]interface{})
-	buf.WriteString(fmt.Sprintf("%d-", m["healthy_threshold"].(int)))
-	buf.WriteString(fmt.Sprintf("%d-", m["unhealthy_threshold"].(int)))
-	buf.WriteString(fmt.Sprintf("%s-", m["target"].(string)))
-	buf.WriteString(fmt.Sprintf("%d-", m["interval"].(int)))
-	buf.WriteString(fmt.Sprintf("%d-", m["timeout"].(int)))
-
-	return hashcode.String(buf.String())
-}
-
-func resourceAwsElbListenerHash(v interface{}) int {
-	var buf bytes.Buffer
-	m := v.(map[string]interface{})
-	buf.WriteString(fmt.Sprintf("%d-", m["instance_port"].(int)))
-	buf.WriteString(fmt.Sprintf("%s-", m["instance_protocol"].(string)))
-	buf.WriteString(fmt.Sprintf("%d-", m["lb_port"].(int)))
-	buf.WriteString(fmt.Sprintf("%s-", m["lb_protocol"].(string)))
-
-	if v, ok := m["ssl_certificate_id"]; ok {
-		buf.WriteString(fmt.Sprintf("%s-", v.(string)))
-	}
-
-	return hashcode.String(buf.String())
-}
-
 func resourceAwsElbCreate(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	elbconn := meta.(*AWSClient).elbconn
-	elbconn := p.elbconn
 
 	// Expand the "listener" set to goamz compat []elb.Listener
 	listeners, err := expandListeners(d.Get("listener").(*schema.Set).List())
@@ -250,9 +222,49 @@ func resourceAwsElbCreate(d *schema.ResourceData, meta interface{}) error {
 	return resourceAwsElbUpdate(d, meta)
 }
 
+func resourceAwsElbRead(d *schema.ResourceData, meta interface{}) error {
+	elbconn := meta.(*AWSClient).elbconn
+
+	// Retrieve the ELB properties for updating the state
+	describeElbOpts := &elb.DescribeLoadBalancer{
+		Names: []string{d.Id()},
+	}
+
+	describeResp, err := elbconn.DescribeLoadBalancers(describeElbOpts)
+	if err != nil {
+		if ec2err, ok := err.(*elb.Error); ok && ec2err.Code == "LoadBalancerNotFound" {
+			// The ELB is gone now, so just remove it from the state
+			d.SetId("")
+			return nil
+		}
+
+		return fmt.Errorf("Error retrieving ELB: %s", err)
+	}
+	if len(describeResp.LoadBalancers) != 1 {
+		return fmt.Errorf("Unable to find ELB: %#v", describeResp.LoadBalancers)
+	}
+
+	lb := describeResp.LoadBalancers[0]
+
+	d.Set("name", lb.LoadBalancerName)
+	d.Set("dns_name", lb.DNSName)
+	d.Set("internal", lb.Scheme == "internal")
+	d.Set("instances", flattenInstances(lb.Instances))
+	d.Set("listener", flattenListeners(lb.Listeners))
+	d.Set("security_groups", lb.SecurityGroups)
+	d.Set("subnets", lb.Subnets)
+
+	// There's only one health check, so save that to state as we
+	// currently can
+	if lb.HealthCheck.Target != "" {
+		d.Set("health_check", flattenHealthCheck(lb.HealthCheck))
+	}
+
+	return nil
+}
+
 func resourceAwsElbUpdate(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	elbconn := meta.(*AWSClient).elbconn
-	elbconn := p.elbconn
 
 	d.Partial(true)
 
@@ -297,8 +309,7 @@ func resourceAwsElbUpdate(d *schema.ResourceData, meta interface{}) error {
 }
 
 func resourceAwsElbDelete(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	elbconn := meta.(*AWSClient).elbconn
-	elbconn := p.elbconn
 
 	log.Printf("[INFO] Deleting ELB: %s", d.Id())
 
@@ -313,44 +324,29 @@ func resourceAwsElbDelete(d *schema.ResourceData, meta interface{}) error {
 	return nil
 }
 
-func resourceAwsElbRead(d *schema.ResourceData, meta interface{}) error {
+func resourceAwsElbHealthCheckHash(v interface{}) int {
-	p := meta.(*ResourceProvider)
+	var buf bytes.Buffer
-	elbconn := p.elbconn
+	m := v.(map[string]interface{})
+	buf.WriteString(fmt.Sprintf("%d-", m["healthy_threshold"].(int)))
+	buf.WriteString(fmt.Sprintf("%d-", m["unhealthy_threshold"].(int)))
+	buf.WriteString(fmt.Sprintf("%s-", m["target"].(string)))
+	buf.WriteString(fmt.Sprintf("%d-", m["interval"].(int)))
+	buf.WriteString(fmt.Sprintf("%d-", m["timeout"].(int)))
 
-	// Retrieve the ELB properties for updating the state
+	return hashcode.String(buf.String())
-	describeElbOpts := &elb.DescribeLoadBalancer{
-		Names: []string{d.Id()},
 }
 
-	describeResp, err := elbconn.DescribeLoadBalancers(describeElbOpts)
+func resourceAwsElbListenerHash(v interface{}) int {
-	if err != nil {
+	var buf bytes.Buffer
-		if ec2err, ok := err.(*elb.Error); ok && ec2err.Code == "LoadBalancerNotFound" {
+	m := v.(map[string]interface{})
-			// The ELB is gone now, so just remove it from the state
+	buf.WriteString(fmt.Sprintf("%d-", m["instance_port"].(int)))
-			d.SetId("")
+	buf.WriteString(fmt.Sprintf("%s-", m["instance_protocol"].(string)))
-			return nil
+	buf.WriteString(fmt.Sprintf("%d-", m["lb_port"].(int)))
+	buf.WriteString(fmt.Sprintf("%s-", m["lb_protocol"].(string)))
+
+	if v, ok := m["ssl_certificate_id"]; ok {
+		buf.WriteString(fmt.Sprintf("%s-", v.(string)))
 	}
 
-		return fmt.Errorf("Error retrieving ELB: %s", err)
+	return hashcode.String(buf.String())
-	}
-	if len(describeResp.LoadBalancers) != 1 {
-		return fmt.Errorf("Unable to find ELB: %#v", describeResp.LoadBalancers)
-	}
-
-	lb := describeResp.LoadBalancers[0]
-
-	d.Set("name", lb.LoadBalancerName)
-	d.Set("dns_name", lb.DNSName)
-	d.Set("internal", lb.Scheme == "internal")
-	d.Set("instances", flattenInstances(lb.Instances))
-	d.Set("listener", flattenListeners(lb.Listeners))
-	d.Set("security_groups", lb.SecurityGroups)
-	d.Set("subnets", lb.Subnets)
-
-	// There's only one health check, so save that to state as we
-	// currently can
-	if lb.HealthCheck.Target != "" {
-		d.Set("health_check", flattenHealthCheck(lb.HealthCheck))
-	}
-
-	return nil
 }

builtin/providers/aws/resource_aws_elb_test.go

@@ -114,7 +114,7 @@ func TestAccAWSELB_HealthCheck(t *testing.T) {
 	})
 }
 func testAccCheckAWSELBDestroy(s *terraform.State) error {
-	conn := testAccProvider.elbconn
+	conn := testAccProvider.Meta().(*AWSClient).elbconn
 
 	for _, rs := range s.RootModule().Resources {
 		if rs.Type != "aws_elb" {
@@ -222,7 +222,7 @@ func testAccCheckAWSELBExists(n string, res *elb.LoadBalancer) resource.TestChec
 			return fmt.Errorf("No ELB ID is set")
 		}
 
-		conn := testAccProvider.elbconn
+		conn := testAccProvider.Meta().(*AWSClient).elbconn
 
 		describe, err := conn.DescribeLoadBalancers(&elb.DescribeLoadBalancer{
 			Names: []string{rs.Primary.ID},

builtin/providers/aws/resource_aws_instance.go

@@ -177,8 +177,7 @@ func resourceAwsInstance() *schema.Resource {
 }
 
 func resourceAwsInstanceCreate(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	ec2conn := meta.(*AWSClient).ec2conn
-	ec2conn := p.ec2conn
 
 	// Figure out user data
 	userData := ""
@@ -288,74 +287,8 @@ func resourceAwsInstanceCreate(d *schema.ResourceData, meta interface{}) error {
 	return resourceAwsInstanceUpdate(d, meta)
 }
 
-func resourceAwsInstanceUpdate(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
-	ec2conn := p.ec2conn
-
-	modify := false
-	opts := new(ec2.ModifyInstance)
-
-	if v, ok := d.GetOk("source_dest_check"); ok {
-		opts.SourceDestCheck = v.(bool)
-		opts.SetSourceDestCheck = true
-		modify = true
-	}
-
-	if modify {
-		log.Printf("[INFO] Modifing instance %s: %#v", d.Id(), opts)
-		if _, err := ec2conn.ModifyInstance(d.Id(), opts); err != nil {
-			return err
-		}
-
-		// TODO(mitchellh): wait for the attributes we modified to
-		// persist the change...
-	}
-
-	if err := setTags(ec2conn, d); err != nil {
-		return err
-	} else {
-		d.SetPartial("tags")
-	}
-
-	return nil
-}
-
-func resourceAwsInstanceDelete(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
-	ec2conn := p.ec2conn
-
-	log.Printf("[INFO] Terminating instance: %s", d.Id())
-	if _, err := ec2conn.TerminateInstances([]string{d.Id()}); err != nil {
-		return fmt.Errorf("Error terminating instance: %s", err)
-	}
-
-	log.Printf(
-		"[DEBUG] Waiting for instance (%s) to become terminated",
-		d.Id())
-
-	stateConf := &resource.StateChangeConf{
-		Pending:    []string{"pending", "running", "shutting-down", "stopped", "stopping"},
-		Target:     "terminated",
-		Refresh:    InstanceStateRefreshFunc(ec2conn, d.Id()),
-		Timeout:    10 * time.Minute,
-		Delay:      10 * time.Second,
-		MinTimeout: 3 * time.Second,
-	}
-
-	_, err := stateConf.WaitForState()
-	if err != nil {
-		return fmt.Errorf(
-			"Error waiting for instance (%s) to terminate: %s",
-			d.Id(), err)
-	}
-
-	d.SetId("")
-	return nil
-}
-
 func resourceAwsInstanceRead(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	ec2conn := meta.(*AWSClient).ec2conn
-	ec2conn := p.ec2conn
 
 	resp, err := ec2conn.Instances([]string{d.Id()}, ec2.NewFilter())
 	if err != nil {
@@ -450,6 +383,69 @@ func resourceAwsInstanceRead(d *schema.ResourceData, meta interface{}) error {
 	return nil
 }
 
+func resourceAwsInstanceUpdate(d *schema.ResourceData, meta interface{}) error {
+	ec2conn := meta.(*AWSClient).ec2conn
+
+	modify := false
+	opts := new(ec2.ModifyInstance)
+
+	if v, ok := d.GetOk("source_dest_check"); ok {
+		opts.SourceDestCheck = v.(bool)
+		opts.SetSourceDestCheck = true
+		modify = true
+	}
+
+	if modify {
+		log.Printf("[INFO] Modifing instance %s: %#v", d.Id(), opts)
+		if _, err := ec2conn.ModifyInstance(d.Id(), opts); err != nil {
+			return err
+		}
+
+		// TODO(mitchellh): wait for the attributes we modified to
+		// persist the change...
+	}
+
+	if err := setTags(ec2conn, d); err != nil {
+		return err
+	} else {
+		d.SetPartial("tags")
+	}
+
+	return nil
+}
+
+func resourceAwsInstanceDelete(d *schema.ResourceData, meta interface{}) error {
+	ec2conn := meta.(*AWSClient).ec2conn
+
+	log.Printf("[INFO] Terminating instance: %s", d.Id())
+	if _, err := ec2conn.TerminateInstances([]string{d.Id()}); err != nil {
+		return fmt.Errorf("Error terminating instance: %s", err)
+	}
+
+	log.Printf(
+		"[DEBUG] Waiting for instance (%s) to become terminated",
+		d.Id())
+
+	stateConf := &resource.StateChangeConf{
+		Pending:    []string{"pending", "running", "shutting-down", "stopped", "stopping"},
+		Target:     "terminated",
+		Refresh:    InstanceStateRefreshFunc(ec2conn, d.Id()),
+		Timeout:    10 * time.Minute,
+		Delay:      10 * time.Second,
+		MinTimeout: 3 * time.Second,
+	}
+
+	_, err := stateConf.WaitForState()
+	if err != nil {
+		return fmt.Errorf(
+			"Error waiting for instance (%s) to terminate: %s",
+			d.Id(), err)
+	}
+
+	d.SetId("")
+	return nil
+}
+
 // InstanceStateRefreshFunc returns a resource.StateRefreshFunc that is used to watch
 // an EC2 instance.
 func InstanceStateRefreshFunc(conn *ec2.EC2, instanceID string) resource.StateRefreshFunc {

builtin/providers/aws/resource_aws_instance_test.go

@@ -189,7 +189,7 @@ func TestAccInstance_tags(t *testing.T) {
 }
 
 func testAccCheckInstanceDestroy(s *terraform.State) error {
-	conn := testAccProvider.ec2conn
+	conn := testAccProvider.Meta().(*AWSClient).ec2conn
 
 	for _, rs := range s.RootModule().Resources {
 		if rs.Type != "aws_instance" {
@@ -231,7 +231,7 @@ func testAccCheckInstanceExists(n string, i *ec2.Instance) resource.TestCheckFun
 			return fmt.Errorf("No ID is set")
 		}
 
-		conn := testAccProvider.ec2conn
+		conn := testAccProvider.Meta().(*AWSClient).ec2conn
 		resp, err := conn.Instances(
 			[]string{rs.Primary.ID}, ec2.NewFilter())
 		if err != nil {
@@ -343,6 +343,8 @@ resource "aws_instance" "foo" {
 
 const testAccCheckInstanceConfigTags = `
 resource "aws_instance" "foo" {
+	ami = "ami-4fccb37f"
+	instance_type = "m1.small"
 	tags {
 		foo = "bar"
 	}
@@ -351,6 +353,8 @@ resource "aws_instance" "foo" {
 
 const testAccCheckInstanceConfigTagsUpdate = `
 resource "aws_instance" "foo" {
+	ami = "ami-4fccb37f"
+	instance_type = "m1.small"
 	tags {
 		bar = "baz"
 	}

builtin/providers/aws/resource_aws_internet_gateway.go

@@ -5,84 +5,88 @@ import (
 	"log"
 	"time"
 
-	"github.com/hashicorp/terraform/helper/diff"
 	"github.com/hashicorp/terraform/helper/resource"
-	"github.com/hashicorp/terraform/terraform"
+	"github.com/hashicorp/terraform/helper/schema"
 	"github.com/mitchellh/goamz/ec2"
 )
 
-func resource_aws_internet_gateway_create(
+func resourceAwsInternetGateway() *schema.Resource {
-	s *terraform.InstanceState,
+	return &schema.Resource{
-	d *terraform.InstanceDiff,
+		Create: resourceAwsInternetGatewayCreate,
-	meta interface{}) (*terraform.InstanceState, error) {
+		Read:   resourceAwsInternetGatewayRead,
-	p := meta.(*ResourceProvider)
+		Update: resourceAwsInternetGatewayUpdate,
-	ec2conn := p.ec2conn
+		Delete: resourceAwsInternetGatewayDelete,
+
+		Schema: map[string]*schema.Schema{
+			"vpc_id": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+		},
+	}
+}
+
+func resourceAwsInternetGatewayCreate(d *schema.ResourceData, meta interface{}) error {
+	ec2conn := meta.(*AWSClient).ec2conn
 
 	// Create the gateway
 	log.Printf("[DEBUG] Creating internet gateway")
 	resp, err := ec2conn.CreateInternetGateway(nil)
 	if err != nil {
-		return nil, fmt.Errorf("Error creating subnet: %s", err)
+		return fmt.Errorf("Error creating internet gateway: %s", err)
 	}
 
 	// Get the ID and store it
 	ig := &resp.InternetGateway
-	s.ID = ig.InternetGatewayId
+	d.SetId(ig.InternetGatewayId)
-	log.Printf("[INFO] InternetGateway ID: %s", s.ID)
+	log.Printf("[INFO] InternetGateway ID: %s", d.Id())
 
-	// Update our attributes and return
+	// Attach the new gateway to the correct vpc
-	return resource_aws_internet_gateway_update(s, d, meta)
+	return resourceAwsInternetGatewayAttach(d, meta)
 }
 
-func resource_aws_internet_gateway_update(
+func resourceAwsInternetGatewayRead(d *schema.ResourceData, meta interface{}) error {
-	s *terraform.InstanceState,
+	ec2conn := meta.(*AWSClient).ec2conn
-	d *terraform.InstanceDiff,
-	meta interface{}) (*terraform.InstanceState, error) {
-	p := meta.(*ResourceProvider)
-	ec2conn := p.ec2conn
 
-	// Merge the diff so we have the latest attributes
+	igRaw, _, err := IGStateRefreshFunc(ec2conn, d.Id())()
-	rs := s.MergeDiff(d)
-
-	// A note on the states below: the AWS docs (as of July, 2014) say
-	// that the states would be: attached, attaching, detached, detaching,
-	// but when running, I noticed that the state is usually "available" when
-	// it is attached.
-
-	// If we're already attached, detach it first
-	if err := resource_aws_internet_gateway_detach(ec2conn, s); err != nil {
-		return s, err
-	}
-
-	// Set the VPC ID to empty since we're detached at this point
-	delete(rs.Attributes, "vpc_id")
-
-	if attr, ok := d.Attributes["vpc_id"]; ok && attr.New != "" {
-		err := resource_aws_internet_gateway_attach(ec2conn, s, attr.New)
 	if err != nil {
-			return rs, err
+		return err
+	}
+	if igRaw == nil {
+		// Seems we have lost our internet gateway
+		d.SetId("")
+		return nil
 	}
 
-		rs.Attributes["vpc_id"] = attr.New
+	ig := igRaw.(*ec2.InternetGateway)
+	d.Set("vpc_id", ig.Attachments[0].VpcId)
+
+	return nil
 }
 
-	return resource_aws_internet_gateway_update_state(rs, nil)
+func resourceAwsInternetGatewayUpdate(d *schema.ResourceData, meta interface{}) error {
-}
+	// If we're already attached, detach it first
-
+	if err := resourceAwsInternetGatewayDetach(d, meta); err != nil {
-func resource_aws_internet_gateway_destroy(
-	s *terraform.InstanceState,
-	meta interface{}) error {
-	p := meta.(*ResourceProvider)
-	ec2conn := p.ec2conn
-
-	// Detach if it is attached
-	if err := resource_aws_internet_gateway_detach(ec2conn, s); err != nil {
 		return err
 	}
 
-	log.Printf("[INFO] Deleting Internet Gateway: %s", s.ID)
+	// Attach the gateway to the new vpc
+	return resourceAwsInternetGatewayAttach(d, meta)
+}
+
+func resourceAwsInternetGatewayDelete(d *schema.ResourceData, meta interface{}) error {
+	ec2conn := meta.(*AWSClient).ec2conn
+
+	// Detach if it is attached
+	if err := resourceAwsInternetGatewayDetach(d, meta); err != nil {
+		return err
+	}
+
+	log.Printf("[INFO] Deleting Internet Gateway: %s", d.Id())
+
 	return resource.Retry(5*time.Minute, func() error {
-		_, err := ec2conn.DeleteInternetGateway(s.ID)
+		_, err := ec2conn.DeleteInternetGateway(d.Id())
 		if err != nil {
 			ec2err, ok := err.(*ec2.Error)
 			if !ok {
@@ -103,96 +107,67 @@ func resource_aws_internet_gateway_destroy(
 	})
 
 	// Wait for the internet gateway to actually delete
-	log.Printf("[DEBUG] Waiting for internet gateway (%s) to delete", s.ID)
+	log.Printf("[DEBUG] Waiting for internet gateway (%s) to delete", d.Id())
 	stateConf := &resource.StateChangeConf{
 		Pending: []string{"available"},
 		Target:  "",
-		Refresh: IGStateRefreshFunc(ec2conn, s.ID),
+		Refresh: IGStateRefreshFunc(ec2conn, d.Id()),
 		Timeout: 10 * time.Minute,
 	}
 	if _, err := stateConf.WaitForState(); err != nil {
 		return fmt.Errorf(
 			"Error waiting for internet gateway (%s) to destroy: %s",
-			s.ID, err)
+			d.Id(), err)
 	}
 
 	return nil
 }
 
-func resource_aws_internet_gateway_refresh(
+func resourceAwsInternetGatewayAttach(d *schema.ResourceData, meta interface{}) error {
-	s *terraform.InstanceState,
+	ec2conn := meta.(*AWSClient).ec2conn
-	meta interface{}) (*terraform.InstanceState, error) {
-	p := meta.(*ResourceProvider)
-	ec2conn := p.ec2conn
 
-	igRaw, _, err := IGStateRefreshFunc(ec2conn, s.ID)()
-	if err != nil {
-		return s, err
-	}
-	if igRaw == nil {
-		return nil, nil
-	}
-
-	ig := igRaw.(*ec2.InternetGateway)
-	return resource_aws_internet_gateway_update_state(s, ig)
-}
-
-func resource_aws_internet_gateway_diff(
-	s *terraform.InstanceState,
-	c *terraform.ResourceConfig,
-	meta interface{}) (*terraform.InstanceDiff, error) {
-	b := &diff.ResourceBuilder{
-		Attrs: map[string]diff.AttrType{
-			"vpc_id": diff.AttrTypeUpdate,
-		},
-	}
-
-	return b.Diff(s, c)
-}
-
-func resource_aws_internet_gateway_attach(
-	ec2conn *ec2.EC2,
-	s *terraform.InstanceState,
-	vpcId string) error {
 	log.Printf(
 		"[INFO] Attaching Internet Gateway '%s' to VPC '%s'",
-		s.ID,
+		d.Id(),
-		vpcId)
+		d.Get("vpc_id").(string))
-	_, err := ec2conn.AttachInternetGateway(s.ID, vpcId)
+
+	_, err := ec2conn.AttachInternetGateway(d.Id(), d.Get("vpc_id").(string))
 	if err != nil {
 		return err
 	}
 
+	// A note on the states below: the AWS docs (as of July, 2014) say
+	// that the states would be: attached, attaching, detached, detaching,
+	// but when running, I noticed that the state is usually "available" when
+	// it is attached.
+
 	// Wait for it to be fully attached before continuing
-	log.Printf("[DEBUG] Waiting for internet gateway (%s) to attach", s.ID)
+	log.Printf("[DEBUG] Waiting for internet gateway (%s) to attach", d.Id())
 	stateConf := &resource.StateChangeConf{
 		Pending: []string{"detached", "attaching"},
 		Target:  "available",
-		Refresh: IGAttachStateRefreshFunc(ec2conn, s.ID, "available"),
+		Refresh: IGAttachStateRefreshFunc(ec2conn, d.Id(), "available"),
 		Timeout: 1 * time.Minute,
 	}
 	if _, err := stateConf.WaitForState(); err != nil {
 		return fmt.Errorf(
 			"Error waiting for internet gateway (%s) to attach: %s",
-			s.ID, err)
+			d.Id(), err)
 	}
 
 	return nil
 }
 
-func resource_aws_internet_gateway_detach(
+func resourceAwsInternetGatewayDetach(d *schema.ResourceData, meta interface{}) error {
-	ec2conn *ec2.EC2,
+	ec2conn := meta.(*AWSClient).ec2conn
-	s *terraform.InstanceState) error {
-	if s.Attributes["vpc_id"] == "" {
-		return nil
-	}
 
 	log.Printf(
 		"[INFO] Detaching Internet Gateway '%s' from VPC '%s'",
-		s.ID,
+		d.Id(),
-		s.Attributes["vpc_id"])
+		d.Get("vpc_id").(string))
+
 	wait := true
-	_, err := ec2conn.DetachInternetGateway(s.ID, s.Attributes["vpc_id"])
+	_, err := ec2conn.DetachInternetGateway(d.Id(), d.Get("vpc_id").(string))
 	if err != nil {
 		ec2err, ok := err.(*ec2.Error)
 		if ok {
@@ -210,40 +185,32 @@ func resource_aws_internet_gateway_detach(
 		}
 	}
 
-	delete(s.Attributes, "vpc_id")
-
 	if !wait {
 		return nil
 	}
 
 	// Wait for it to be fully detached before continuing
-	log.Printf("[DEBUG] Waiting for internet gateway (%s) to detach", s.ID)
+	log.Printf("[DEBUG] Waiting for internet gateway (%s) to detach", d.Id())
 	stateConf := &resource.StateChangeConf{
 		Pending: []string{"attached", "detaching", "available"},
 		Target:  "detached",
-		Refresh: IGAttachStateRefreshFunc(ec2conn, s.ID, "detached"),
+		Refresh: IGAttachStateRefreshFunc(ec2conn, d.Id(), "detached"),
 		Timeout: 1 * time.Minute,
 	}
 	if _, err := stateConf.WaitForState(); err != nil {
 		return fmt.Errorf(
 			"Error waiting for internet gateway (%s) to detach: %s",
-			s.ID, err)
+			d.Id(), err)
 	}
 
 	return nil
 }
 
-func resource_aws_internet_gateway_update_state(
-	s *terraform.InstanceState,
-	ig *ec2.InternetGateway) (*terraform.InstanceState, error) {
-	return s, nil
-}
-
 // IGStateRefreshFunc returns a resource.StateRefreshFunc that is used to watch
 // an internet gateway.
-func IGStateRefreshFunc(conn *ec2.EC2, id string) resource.StateRefreshFunc {
+func IGStateRefreshFunc(ec2conn *ec2.EC2, id string) resource.StateRefreshFunc {
 	return func() (interface{}, string, error) {
-		resp, err := conn.DescribeInternetGateways([]string{id}, ec2.NewFilter())
+		resp, err := ec2conn.DescribeInternetGateways([]string{id}, ec2.NewFilter())
 		if err != nil {
 			ec2err, ok := err.(*ec2.Error)
 			if ok && ec2err.Code == "InvalidInternetGatewayID.NotFound" {

builtin/providers/aws/resource_aws_internet_gateway_test.go

@@ -55,7 +55,7 @@ func TestAccAWSInternetGateway(t *testing.T) {
 }
 
 func testAccCheckInternetGatewayDestroy(s *terraform.State) error {
-	conn := testAccProvider.ec2conn
+	conn := testAccProvider.Meta().(*AWSClient).ec2conn
 
 	for _, rs := range s.RootModule().Resources {
 		if rs.Type != "aws_internet_gateway" {
@@ -97,7 +97,7 @@ func testAccCheckInternetGatewayExists(n string, ig *ec2.InternetGateway) resour
 			return fmt.Errorf("No ID is set")
 		}
 
-		conn := testAccProvider.ec2conn
+		conn := testAccProvider.Meta().(*AWSClient).ec2conn
 		resp, err := conn.DescribeInternetGateways(
 			[]string{rs.Primary.ID}, ec2.NewFilter())
 		if err != nil {

builtin/providers/aws/resource_aws_launch_configuration.go

@@ -86,8 +86,7 @@ func resourceAwsLaunchConfiguration() *schema.Resource {
 }
 
 func resourceAwsLaunchConfigurationCreate(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	autoscalingconn := meta.(*AWSClient).autoscalingconn
-	autoscalingconn := p.autoscalingconn
 
 	var createLaunchConfigurationOpts autoscaling.CreateLaunchConfiguration
 	createLaunchConfigurationOpts.Name = d.Get("name").(string)
@@ -119,28 +118,8 @@ func resourceAwsLaunchConfigurationCreate(d *schema.ResourceData, meta interface
 	})
 }
 
-func resourceAwsLaunchConfigurationDelete(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
-	autoscalingconn := p.autoscalingconn
-
-	log.Printf("[DEBUG] Launch Configuration destroy: %v", d.Id())
-	_, err := autoscalingconn.DeleteLaunchConfiguration(
-		&autoscaling.DeleteLaunchConfiguration{Name: d.Id()})
-	if err != nil {
-		autoscalingerr, ok := err.(*autoscaling.Error)
-		if ok && autoscalingerr.Code == "InvalidConfiguration.NotFound" {
-			return nil
-		}
-
-		return err
-	}
-
-	return nil
-}
-
 func resourceAwsLaunchConfigurationRead(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	autoscalingconn := meta.(*AWSClient).autoscalingconn
-	autoscalingconn := p.autoscalingconn
 
 	describeOpts := autoscaling.DescribeLaunchConfigurations{
 		Names: []string{d.Id()},
@@ -174,3 +153,21 @@ func resourceAwsLaunchConfigurationRead(d *schema.ResourceData, meta interface{}
 
 	return nil
 }
+
+func resourceAwsLaunchConfigurationDelete(d *schema.ResourceData, meta interface{}) error {
+	autoscalingconn := meta.(*AWSClient).autoscalingconn
+
+	log.Printf("[DEBUG] Launch Configuration destroy: %v", d.Id())
+	_, err := autoscalingconn.DeleteLaunchConfiguration(
+		&autoscaling.DeleteLaunchConfiguration{Name: d.Id()})
+	if err != nil {
+		autoscalingerr, ok := err.(*autoscaling.Error)
+		if ok && autoscalingerr.Code == "InvalidConfiguration.NotFound" {
+			return nil
+		}
+
+		return err
+	}
+
+	return nil
+}

builtin/providers/aws/resource_aws_launch_configuration_test.go

@@ -37,7 +37,7 @@ func TestAccAWSLaunchConfiguration(t *testing.T) {
 }
 
 func testAccCheckAWSLaunchConfigurationDestroy(s *terraform.State) error {
-	conn := testAccProvider.autoscalingconn
+	conn := testAccProvider.Meta().(*AWSClient).autoscalingconn
 
 	for _, rs := range s.RootModule().Resources {
 		if rs.Type != "aws_launch_configuration" {
@@ -98,7 +98,7 @@ func testAccCheckAWSLaunchConfigurationExists(n string, res *autoscaling.LaunchC
 			return fmt.Errorf("No Launch Configuration ID is set")
 		}
 
-		conn := testAccProvider.autoscalingconn
+		conn := testAccProvider.Meta().(*AWSClient).autoscalingconn
 
 		describeOpts := autoscaling.DescribeLaunchConfigurations{
 			Names: []string{rs.Primary.ID},

builtin/providers/aws/resource_aws_route53_record.go

@@ -3,45 +3,62 @@ package aws
 import (
 	"fmt"
 	"log"
-	"strconv"
 	"strings"
 	"time"
 
-	"github.com/hashicorp/terraform/flatmap"
-	"github.com/hashicorp/terraform/helper/config"
-	"github.com/hashicorp/terraform/helper/diff"
 	"github.com/hashicorp/terraform/helper/resource"
-	"github.com/hashicorp/terraform/terraform"
+	"github.com/hashicorp/terraform/helper/schema"
 	"github.com/mitchellh/goamz/route53"
 )
 
-func resource_aws_r53_record_validation() *config.Validator {
+func resourceAwsRoute53Record() *schema.Resource {
-	return &config.Validator{
+	return &schema.Resource{
-		Required: []string{
+		Create: resourceAwsRoute53RecordCreate,
-			"zone_id",
+		Read:   resourceAwsRoute53RecordRead,
-			"name",
+		Delete: resourceAwsRoute53RecordDelete,
-			"type",
+
-			"ttl",
+		Schema: map[string]*schema.Schema{
-			"records.*",
+			"name": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"type": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"zone_id": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"ttl": &schema.Schema{
+				Type:     schema.TypeInt,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"records": &schema.Schema{
+				Type:     schema.TypeList,
+				Elem:     &schema.Schema{Type: schema.TypeString},
+				Required: true,
+				ForceNew: true,
+			},
 		},
 	}
 }
 
-func resource_aws_r53_record_create(
+func resourceAwsRoute53RecordCreate(d *schema.ResourceData, meta interface{}) error {
-	s *terraform.InstanceState,
+	conn := meta.(*AWSClient).route53
-	d *terraform.InstanceDiff,
-	meta interface{}) (*terraform.InstanceState, error) {
-	p := meta.(*ResourceProvider)
-	conn := p.route53
-
-	// Merge the diff into the state so that we have all the attributes
-	// properly.
-	rs := s.MergeDiff(d)
 
 	// Get the record
-	rec, err := resource_aws_r53_build_record_set(rs)
+	rec, err := resourceAwsRoute53RecordBuildSet(d)
 	if err != nil {
-		return rs, err
+		return err
 	}
 
 	// Create the new records. We abuse StateChangeConf for this to
@@ -56,9 +73,10 @@ func resource_aws_r53_record_create(
 			},
 		},
 	}
-	zone := rs.Attributes["zone_id"]
+	zone := d.Get("zone_id").(string)
 	log.Printf("[DEBUG] Creating resource records for zone: %s, name: %s",
-		zone, rs.Attributes["name"])
+		zone, d.Get("name").(string))
+
 	wait := resource.StateChangeConf{
 		Pending:    []string{"rejected"},
 		Target:     "accepted",
@@ -79,14 +97,15 @@ func resource_aws_r53_record_create(
 			return resp.ChangeInfo, "accepted", nil
 		},
 	}
+
 	respRaw, err := wait.WaitForState()
 	if err != nil {
-		return rs, err
+		return err
 	}
 	changeInfo := respRaw.(route53.ChangeInfo)
 
 	// Generate an ID
-	rs.ID = fmt.Sprintf("%s_%s_%s", zone, rs.Attributes["name"], rs.Attributes["type"])
+	d.SetId(fmt.Sprintf("%s_%s_%s", zone, d.Get("name").(string), d.Get("type").(string)))
 
 	// Wait until we are done
 	wait = resource.StateChangeConf{
@@ -96,47 +115,63 @@ func resource_aws_r53_record_create(
 		Timeout:    10 * time.Minute,
 		MinTimeout: 5 * time.Second,
 		Refresh: func() (result interface{}, state string, err error) {
-			return resource_aws_r53_wait(conn, changeInfo.ID)
+			return resourceAwsRoute53Wait(conn, changeInfo.ID)
 		},
 	}
 	_, err = wait.WaitForState()
 	if err != nil {
-		return rs, err
+		return err
-	}
-	return rs, nil
 	}
 
-func resource_aws_r53_build_record_set(s *terraform.InstanceState) (*route53.ResourceRecordSet, error) {
+	return nil
-	// Parse the TTL
+}
-	ttl, err := strconv.ParseInt(s.Attributes["ttl"], 10, 32)
+
+func resourceAwsRoute53RecordRead(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).route53
+
+	zone := d.Get("zone_id").(string)
+	lopts := &route53.ListOpts{
+		Name: d.Get("name").(string),
+		Type: d.Get("type").(string),
+	}
+	resp, err := conn.ListResourceRecordSets(zone, lopts)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	// Expand the records
+	// Scan for a matching record
-	recRaw := flatmap.Expand(s.Attributes, "records")
+	found := false
-	var records []string
+	for _, record := range resp.Records {
-	for _, raw := range recRaw.([]interface{}) {
+		if route53.FQDN(record.Name) != route53.FQDN(lopts.Name) {
-		records = append(records, raw.(string))
+			continue
+		}
+		if strings.ToUpper(record.Type) != strings.ToUpper(lopts.Type) {
+			continue
 		}
 
-	rec := &route53.ResourceRecordSet{
+		found = true
-		Name:    s.Attributes["name"],
+
-		Type:    s.Attributes["type"],
+		for i, rec := range record.Records {
-		TTL:     int(ttl),
+			key := fmt.Sprintf("records.%d", i)
-		Records: records,
+			d.Set(key, rec)
 		}
-	return rec, nil
+		d.Set("ttl", record.TTL)
+
+		break
 	}
 
-func resource_aws_r53_record_destroy(
+	if !found {
-	s *terraform.InstanceState,
+		d.SetId("")
-	meta interface{}) error {
+	}
-	p := meta.(*ResourceProvider)
-	conn := p.route53
 
-	// Get the record
+	return nil
-	rec, err := resource_aws_r53_build_record_set(s)
+}
+
+func resourceAwsRoute53RecordDelete(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).route53
+
+	// Get the records
+	rec, err := resourceAwsRoute53RecordBuildSet(d)
 	if err != nil {
 		return err
 	}
@@ -151,9 +186,10 @@ func resource_aws_r53_record_destroy(
 			},
 		},
 	}
-	zone := s.Attributes["zone_id"]
+	zone := d.Get("zone_id").(string)
 	log.Printf("[DEBUG] Deleting resource records for zone: %s, name: %s",
-		zone, s.Attributes["name"])
+		zone, d.Get("name").(string))
+
 	wait := resource.StateChangeConf{
 		Pending:    []string{"rejected"},
 		Target:     "accepted",
@@ -179,6 +215,7 @@ func resource_aws_r53_record_destroy(
 			return 42, "accepted", nil
 		},
 	}
+
 	if _, err := wait.WaitForState(); err != nil {
 		return err
 	}
@@ -186,68 +223,19 @@ func resource_aws_r53_record_destroy(
 	return nil
 }
 
-func resource_aws_r53_record_refresh(
+func resourceAwsRoute53RecordBuildSet(d *schema.ResourceData) (*route53.ResourceRecordSet, error) {
-	s *terraform.InstanceState,
+	recs := d.Get("records.#").(int)
-	meta interface{}) (*terraform.InstanceState, error) {
+	records := make([]string, 0, recs)
-	p := meta.(*ResourceProvider)
+	for i := 0; i < recs; i++ {
-	conn := p.route53
+		key := fmt.Sprintf("records.%d", i)
-
+		records = append(records, d.Get(key).(string))
-	zone := s.Attributes["zone_id"]
-	lopts := &route53.ListOpts{
-		Name: s.Attributes["name"],
-		Type: s.Attributes["type"],
-	}
-	resp, err := conn.ListResourceRecordSets(zone, lopts)
-	if err != nil {
-		return s, err
 	}
 
-	// Scan for a matching record
+	rec := &route53.ResourceRecordSet{
-	found := false
+		Name:    d.Get("name").(string),
-	for _, record := range resp.Records {
+		Type:    d.Get("type").(string),
-		if route53.FQDN(record.Name) != route53.FQDN(lopts.Name) {
+		TTL:     d.Get("ttl").(int),
-			continue
+		Records: records,
 	}
-		if strings.ToUpper(record.Type) != strings.ToUpper(lopts.Type) {
+	return rec, nil
-			continue
-		}
-
-		found = true
-		resource_aws_r53_record_update_state(s, &record)
-		break
-	}
-	if !found {
-		s.ID = ""
-	}
-	return s, nil
-}
-
-func resource_aws_r53_record_update_state(
-	s *terraform.InstanceState,
-	rec *route53.ResourceRecordSet) {
-
-	flatRec := flatmap.Flatten(map[string]interface{}{
-		"records": rec.Records,
-	})
-	for k, v := range flatRec {
-		s.Attributes[k] = v
-	}
-
-	s.Attributes["ttl"] = strconv.FormatInt(int64(rec.TTL), 10)
-}
-
-func resource_aws_r53_record_diff(
-	s *terraform.InstanceState,
-	c *terraform.ResourceConfig,
-	meta interface{}) (*terraform.InstanceDiff, error) {
-	b := &diff.ResourceBuilder{
-		Attrs: map[string]diff.AttrType{
-			"zone_id": diff.AttrTypeCreate,
-			"name":    diff.AttrTypeCreate,
-			"type":    diff.AttrTypeCreate,
-			"ttl":     diff.AttrTypeUpdate,
-			"records": diff.AttrTypeUpdate,
-		},
-	}
-	return b.Diff(s, c)
 }

builtin/providers/aws/resource_aws_route53_record_test.go

@@ -27,7 +27,7 @@ func TestAccRoute53Record(t *testing.T) {
 }
 
 func testAccCheckRoute53RecordDestroy(s *terraform.State) error {
-	conn := testAccProvider.route53
+	conn := testAccProvider.Meta().(*AWSClient).route53
 	for _, rs := range s.RootModule().Resources {
 		if rs.Type != "aws_route53_record" {
 			continue
@@ -56,7 +56,7 @@ func testAccCheckRoute53RecordDestroy(s *terraform.State) error {
 
 func testAccCheckRoute53RecordExists(n string) resource.TestCheckFunc {
 	return func(s *terraform.State) error {
-		conn := testAccProvider.route53
+		conn := testAccProvider.Meta().(*AWSClient).route53
 		rs, ok := s.RootModule().Resources[n]
 		if !ok {
 			return fmt.Errorf("Not found: %s", n)

builtin/providers/aws/resource_aws_route53_zone.go

@@ -5,46 +5,49 @@ import (
 	"strings"
 	"time"
 
-	"github.com/hashicorp/terraform/helper/config"
-	"github.com/hashicorp/terraform/helper/diff"
 	"github.com/hashicorp/terraform/helper/resource"
-	"github.com/hashicorp/terraform/terraform"
+	"github.com/hashicorp/terraform/helper/schema"
 	"github.com/mitchellh/goamz/route53"
 )
 
-func resource_aws_r53_zone_validation() *config.Validator {
+func resourceAwsRoute53Zone() *schema.Resource {
-	return &config.Validator{
+	return &schema.Resource{
-		Required: []string{
+		Create: resourceAwsRoute53ZoneCreate,
-			"name",
+		Read:   resourceAwsRoute53ZoneRead,
+		Delete: resourceAwsRoute53ZoneDelete,
+
+		Schema: map[string]*schema.Schema{
+			"name": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"zone_id": &schema.Schema{
+				Type:     schema.TypeString,
+				Computed: true,
+			},
 		},
 	}
 }
 
-func resource_aws_r53_zone_create(
+func resourceAwsRoute53ZoneCreate(d *schema.ResourceData, meta interface{}) error {
-	s *terraform.InstanceState,
+	r53 := meta.(*AWSClient).route53
-	d *terraform.InstanceDiff,
-	meta interface{}) (*terraform.InstanceState, error) {
-	p := meta.(*ResourceProvider)
-	r53 := p.route53
-
-	// Merge the diff into the state so that we have all the attributes
-	// properly.
-	rs := s.MergeDiff(d)
 
 	req := &route53.CreateHostedZoneRequest{
-		Name:    rs.Attributes["name"],
+		Name:    d.Get("name").(string),
 		Comment: "Managed by Terraform",
 	}
 	log.Printf("[DEBUG] Creating Route53 hosted zone: %s", req.Name)
 	resp, err := r53.CreateHostedZone(req)
 	if err != nil {
-		return rs, err
+		return err
 	}
 
 	// Store the zone_id
 	zone := route53.CleanZoneID(resp.HostedZone.ID)
-	rs.ID = zone
+	d.Set("zone_id", zone)
-	rs.Attributes["zone_id"] = zone
+	d.SetId(zone)
 
 	// Wait until we are done initializing
 	wait := resource.StateChangeConf{
@@ -54,71 +57,50 @@ func resource_aws_r53_zone_create(
 		Timeout:    10 * time.Minute,
 		MinTimeout: 2 * time.Second,
 		Refresh: func() (result interface{}, state string, err error) {
-			return resource_aws_r53_wait(r53, resp.ChangeInfo.ID)
+			return resourceAwsRoute53Wait(r53, resp.ChangeInfo.ID)
 		},
 	}
 	_, err = wait.WaitForState()
-	if err != nil {
-		return rs, err
-	}
-	return rs, nil
-}
-
-// resource_aws_r53_wait checks the status of a change
-func resource_aws_r53_wait(r53 *route53.Route53, ref string) (result interface{}, state string, err error) {
-	status, err := r53.GetChange(ref)
-	if err != nil {
-		return nil, "UNKNOWN", err
-	}
-	return true, status, nil
-}
-
-func resource_aws_r53_zone_destroy(
-	s *terraform.InstanceState,
-	meta interface{}) error {
-	p := meta.(*ResourceProvider)
-	r53 := p.route53
-
-	log.Printf("[DEBUG] Deleting Route53 hosted zone: %s (ID: %s)",
-		s.Attributes["name"], s.Attributes["zone_id"])
-	_, err := r53.DeleteHostedZone(s.Attributes["zone_id"])
 	if err != nil {
 		return err
 	}
 	return nil
 }
 
-func resource_aws_r53_zone_refresh(
+func resourceAwsRoute53ZoneRead(d *schema.ResourceData, meta interface{}) error {
-	s *terraform.InstanceState,
+	r53 := meta.(*AWSClient).route53
-	meta interface{}) (*terraform.InstanceState, error) {
-	p := meta.(*ResourceProvider)
-	r53 := p.route53
 
-	_, err := r53.GetHostedZone(s.Attributes["zone_id"])
+	_, err := r53.GetHostedZone(d.Id())
 	if err != nil {
 		// Handle a deleted zone
 		if strings.Contains(err.Error(), "404") {
-			s.ID = ""
+			d.SetId("")
-			return s, nil
+			return nil
 		}
-		return s, err
+		return err
-	}
-	return s, nil
 	}
 
-func resource_aws_r53_zone_diff(
+	return nil
-	s *terraform.InstanceState,
-	c *terraform.ResourceConfig,
-	meta interface{}) (*terraform.InstanceDiff, error) {
-
-	b := &diff.ResourceBuilder{
-		Attrs: map[string]diff.AttrType{
-			"name": diff.AttrTypeCreate,
-		},
-
-		ComputedAttrs: []string{
-			"zone_id",
-		},
 }
-	return b.Diff(s, c)
+
+func resourceAwsRoute53ZoneDelete(d *schema.ResourceData, meta interface{}) error {
+	r53 := meta.(*AWSClient).route53
+
+	log.Printf("[DEBUG] Deleting Route53 hosted zone: %s (ID: %s)",
+		d.Get("name").(string), d.Id())
+	_, err := r53.DeleteHostedZone(d.Id())
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// resourceAwsRoute53Wait checks the status of a change
+func resourceAwsRoute53Wait(r53 *route53.Route53, ref string) (result interface{}, state string, err error) {
+	status, err := r53.GetChange(ref)
+	if err != nil {
+		return nil, "UNKNOWN", err
+	}
+	return true, status, nil
 }

builtin/providers/aws/resource_aws_route53_zone_test.go

@@ -25,7 +25,7 @@ func TestAccRoute53Zone(t *testing.T) {
 }
 
 func testAccCheckRoute53ZoneDestroy(s *terraform.State) error {
-	conn := testAccProvider.route53
+	conn := testAccProvider.Meta().(*AWSClient).route53
 	for _, rs := range s.RootModule().Resources {
 		if rs.Type != "aws_route53_zone" {
 			continue
@@ -50,7 +50,7 @@ func testAccCheckRoute53ZoneExists(n string) resource.TestCheckFunc {
 			return fmt.Errorf("No hosted zone ID is set")
 		}
 
-		conn := testAccProvider.route53
+		conn := testAccProvider.Meta().(*AWSClient).route53
 		_, err := conn.GetHostedZone(rs.Primary.ID)
 		if err != nil {
 			return fmt.Errorf("Hosted zone err: %v", err)

builtin/providers/aws/resource_aws_route_table.go

@@ -1,146 +1,192 @@
 package aws
 
 import (
+	"bytes"
 	"fmt"
 	"log"
-	"reflect"
 	"time"
 
-	"github.com/hashicorp/terraform/flatmap"
+	"github.com/hashicorp/terraform/helper/hashcode"
-	"github.com/hashicorp/terraform/helper/diff"
 	"github.com/hashicorp/terraform/helper/resource"
-	"github.com/hashicorp/terraform/terraform"
+	"github.com/hashicorp/terraform/helper/schema"
 	"github.com/mitchellh/goamz/ec2"
 )
 
-func resource_aws_route_table_create(
+func resourceAwsRouteTable() *schema.Resource {
-	s *terraform.InstanceState,
+	return &schema.Resource{
-	d *terraform.InstanceDiff,
+		Create: resourceAwsRouteTableCreate,
-	meta interface{}) (*terraform.InstanceState, error) {
+		Read:   resourceAwsRouteTableRead,
-	p := meta.(*ResourceProvider)
+		Update: resourceAwsRouteTableUpdate,
-	ec2conn := p.ec2conn
+		Delete: resourceAwsRouteTableDelete,
+
+		Schema: map[string]*schema.Schema{
+			"vpc_id": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"route": &schema.Schema{
+				Type:     schema.TypeSet,
+				Optional: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"cidr_block": &schema.Schema{
+							Type:     schema.TypeString,
+							Required: true,
+						},
+
+						"gateway_id": &schema.Schema{
+							Type:     schema.TypeString,
+							Optional: true,
+						},
+
+						"instance_id": &schema.Schema{
+							Type:     schema.TypeString,
+							Optional: true,
+						},
+					},
+				},
+				Set: resourceAwsRouteTableHash,
+			},
+		},
+	}
+}
+
+func resourceAwsRouteTableCreate(d *schema.ResourceData, meta interface{}) error {
+	ec2conn := meta.(*AWSClient).ec2conn
 
 	// Create the routing table
 	createOpts := &ec2.CreateRouteTable{
-		VpcId: d.Attributes["vpc_id"].New,
+		VpcId: d.Get("vpc_id").(string),
 	}
 	log.Printf("[DEBUG] RouteTable create config: %#v", createOpts)
+
 	resp, err := ec2conn.CreateRouteTable(createOpts)
 	if err != nil {
-		return nil, fmt.Errorf("Error creating route table: %s", err)
+		return fmt.Errorf("Error creating route table: %s", err)
 	}
 
 	// Get the ID and store it
 	rt := &resp.RouteTable
-	s.ID = rt.RouteTableId
+	d.SetId(rt.RouteTableId)
-	log.Printf("[INFO] Route Table ID: %s", s.ID)
+	log.Printf("[INFO] Route Table ID: %s", d.Id())
 
 	// Wait for the route table to become available
 	log.Printf(
 		"[DEBUG] Waiting for route table (%s) to become available",
-		s.ID)
+		d.Id())
 	stateConf := &resource.StateChangeConf{
 		Pending: []string{"pending"},
 		Target:  "ready",
-		Refresh: RouteTableStateRefreshFunc(ec2conn, s.ID),
+		Refresh: resourceAwsRouteTableStateRefreshFunc(ec2conn, d.Id()),
 		Timeout: 1 * time.Minute,
 	}
 	if _, err := stateConf.WaitForState(); err != nil {
-		return s, fmt.Errorf(
+		return fmt.Errorf(
 			"Error waiting for route table (%s) to become available: %s",
-			s.ID, err)
+			d.Id(), err)
 	}
 
-	// Update our routes
+	return resourceAwsRouteTableUpdate(d, meta)
-	return resource_aws_route_table_update(s, d, meta)
 }
 
-func resource_aws_route_table_update(
+func resourceAwsRouteTableRead(d *schema.ResourceData, meta interface{}) error {
-	s *terraform.InstanceState,
+	ec2conn := meta.(*AWSClient).ec2conn
-	d *terraform.InstanceDiff,
-	meta interface{}) (*terraform.InstanceState, error) {
-	p := meta.(*ResourceProvider)
-	ec2conn := p.ec2conn
-
-	// Our resulting state
-	rs := s.MergeDiff(d)
-
-	// Get our routes out of the merge
-	oldroutes := flatmap.Expand(s.Attributes, "route")
-	routes := flatmap.Expand(s.MergeDiff(d).Attributes, "route")
-
-	// Determine the route operations we need to perform
-	ops := routeTableOps(oldroutes, routes)
-	if len(ops) == 0 {
-		return s, nil
-	}
-
-	// Go through each operation, performing each one at a time.
-	// We store the updated state on each operation so that if any
-	// individual operation fails, we can return a valid partial state.
-	var err error
-	resultRoutes := make([]map[string]string, 0, len(ops))
-	for _, op := range ops {
-		switch op.Op {
-		case routeTableOpCreate:
-			opts := ec2.CreateRoute{
-				RouteTableId:         s.ID,
-				DestinationCidrBlock: op.Route.DestinationCidrBlock,
-				GatewayId:            op.Route.GatewayId,
-				InstanceId:           op.Route.InstanceId,
-			}
-
-			_, err = ec2conn.CreateRoute(&opts)
-		case routeTableOpReplace:
-			opts := ec2.ReplaceRoute{
-				RouteTableId:         s.ID,
-				DestinationCidrBlock: op.Route.DestinationCidrBlock,
-				GatewayId:            op.Route.GatewayId,
-				InstanceId:           op.Route.InstanceId,
-			}
-
-			_, err = ec2conn.ReplaceRoute(&opts)
-		case routeTableOpDelete:
-			_, err = ec2conn.DeleteRoute(
-				s.ID, op.Route.DestinationCidrBlock)
-		}
 
+	rtRaw, _, err := resourceAwsRouteTableStateRefreshFunc(ec2conn, d.Id())()
 	if err != nil {
-			// Exit early so we can return what we've done so far
+		return err
-			break
+	}
+	if rtRaw == nil {
+		return nil
 	}
 
-		// If we didn't delete the route, append it to the list of routes
+	rt := rtRaw.(*ec2.RouteTable)
-		// we have.
+	d.Set("vpc_id", rt.VpcId)
-		if op.Op != routeTableOpDelete {
+
-			resultMap := map[string]string{"cidr_block": op.Route.DestinationCidrBlock}
+	// Create an empty schema.Set to hold all routes
-			if op.Route.GatewayId != "" {
+	route := &schema.Set{F: resourceAwsRouteTableHash}
-				resultMap["gateway_id"] = op.Route.GatewayId
+
-			} else if op.Route.InstanceId != "" {
+	// Loop through the routes and add them to the set
-				resultMap["instance_id"] = op.Route.InstanceId
+	for _, r := range rt.Routes {
+		if r.GatewayId == "local" {
+			continue
 		}
 
-			resultRoutes = append(resultRoutes, resultMap)
+		m := make(map[string]interface{})
+		m["cidr_block"] = r.DestinationCidrBlock
+
+		if r.GatewayId != "" {
+			m["gateway_id"] = r.GatewayId
+		}
+
+		if r.InstanceId != "" {
+			m["instance_id"] = r.InstanceId
+		}
+
+		route.Add(m)
+	}
+	d.Set("route", route)
+
+	return nil
+}
+
+func resourceAwsRouteTableUpdate(d *schema.ResourceData, meta interface{}) error {
+	ec2conn := meta.(*AWSClient).ec2conn
+
+	// Check if the route set as a whole has changed
+	if d.HasChange("route") {
+		o, n := d.GetChange("route")
+		ors := o.(*schema.Set).Difference(n.(*schema.Set))
+		nrs := n.(*schema.Set).Difference(o.(*schema.Set))
+
+		// Now first loop through all the old routes and delete any obsolete ones
+		for _, route := range ors.List() {
+			m := route.(map[string]interface{})
+
+			// Delete the route as it no longer exists in the config
+			_, err := ec2conn.DeleteRoute(
+				d.Id(), m["cidr_block"].(string))
+			if err != nil {
+				return err
 			}
 		}
 
-	// Update our state with the settings
+		// Make sure we save the state of the currently configured rules
-	flatmap.Map(rs.Attributes).Merge(flatmap.Flatten(map[string]interface{}{
+		routes := o.(*schema.Set).Intersection(n.(*schema.Set))
-		"route": resultRoutes,
+		d.Set("route", routes)
-	}))
 
-	return rs, err
+		// Then loop through al the newly configured routes and create them
+		for _, route := range nrs.List() {
+			m := route.(map[string]interface{})
+
+			opts := ec2.CreateRoute{
+				RouteTableId:         d.Id(),
+				DestinationCidrBlock: m["cidr_block"].(string),
+				GatewayId:            m["gateway_id"].(string),
+				InstanceId:           m["instance_id"].(string),
 			}
 
-func resource_aws_route_table_destroy(
+			_, err := ec2conn.CreateRoute(&opts)
-	s *terraform.InstanceState,
+			if err != nil {
-	meta interface{}) error {
+				return err
-	p := meta.(*ResourceProvider)
+			}
-	ec2conn := p.ec2conn
+
+			routes.Add(route)
+			d.Set("route", routes)
+		}
+	}
+
+	return resourceAwsRouteTableRead(d, meta)
+}
+
+func resourceAwsRouteTableDelete(d *schema.ResourceData, meta interface{}) error {
+	ec2conn := meta.(*AWSClient).ec2conn
 
 	// First request the routing table since we'll have to disassociate
 	// all the subnets first.
-	rtRaw, _, err := RouteTableStateRefreshFunc(ec2conn, s.ID)()
+	rtRaw, _, err := resourceAwsRouteTableStateRefreshFunc(ec2conn, d.Id())()
 	if err != nil {
 		return err
 	}
@@ -158,8 +204,8 @@ func resource_aws_route_table_destroy(
 	}
 
 	// Delete the route table
-	log.Printf("[INFO] Deleting Route Table: %s", s.ID)
+	log.Printf("[INFO] Deleting Route Table: %s", d.Id())
-	if _, err := ec2conn.DeleteRouteTable(s.ID); err != nil {
+	if _, err := ec2conn.DeleteRouteTable(d.Id()); err != nil {
 		ec2err, ok := err.(*ec2.Error)
 		if ok && ec2err.Code == "InvalidRouteTableID.NotFound" {
 			return nil
@@ -171,147 +217,42 @@ func resource_aws_route_table_destroy(
 	// Wait for the route table to really destroy
 	log.Printf(
 		"[DEBUG] Waiting for route table (%s) to become destroyed",
-		s.ID)
+		d.Id())
+
 	stateConf := &resource.StateChangeConf{
 		Pending: []string{"ready"},
 		Target:  "",
-		Refresh: RouteTableStateRefreshFunc(ec2conn, s.ID),
+		Refresh: resourceAwsRouteTableStateRefreshFunc(ec2conn, d.Id()),
 		Timeout: 1 * time.Minute,
 	}
 	if _, err := stateConf.WaitForState(); err != nil {
 		return fmt.Errorf(
 			"Error waiting for route table (%s) to become destroyed: %s",
-			s.ID, err)
+			d.Id(), err)
 	}
 
 	return nil
 }
 
-func resource_aws_route_table_refresh(
+func resourceAwsRouteTableHash(v interface{}) int {
-	s *terraform.InstanceState,
+	var buf bytes.Buffer
-	meta interface{}) (*terraform.InstanceState, error) {
+	m := v.(map[string]interface{})
-	p := meta.(*ResourceProvider)
+	buf.WriteString(fmt.Sprintf("%s-", m["cidr_block"].(string)))
-	ec2conn := p.ec2conn
 
-	rtRaw, _, err := RouteTableStateRefreshFunc(ec2conn, s.ID)()
-	if err != nil {
-		return s, err
-	}
-	if rtRaw == nil {
-		return nil, nil
-	}
-
-	rt := rtRaw.(*ec2.RouteTable)
-	return resource_aws_route_table_update_state(s, rt)
-}
-
-func resource_aws_route_table_diff(
-	s *terraform.InstanceState,
-	c *terraform.ResourceConfig,
-	meta interface{}) (*terraform.InstanceDiff, error) {
-	b := &diff.ResourceBuilder{
-		Attrs: map[string]diff.AttrType{
-			"vpc_id": diff.AttrTypeCreate,
-			"route":  diff.AttrTypeUpdate,
-		},
-	}
-
-	return b.Diff(s, c)
-}
-
-func resource_aws_route_table_update_state(
-	s *terraform.InstanceState,
-	rt *ec2.RouteTable) (*terraform.InstanceState, error) {
-	s.Attributes["vpc_id"] = rt.VpcId
-
-	return s, nil
-}
-
-// routeTableOp represents a minor operation on the routing table.
-// This tells us what we should do to the routing table.
-type routeTableOp struct {
-	Op    routeTableOpType
-	Route ec2.Route
-}
-
-// routeTableOpType is the type of operation related to a route that
-// can be operated on a routing table.
-type routeTableOpType byte
-
-const (
-	routeTableOpCreate routeTableOpType = iota
-	routeTableOpReplace
-	routeTableOpDelete
-)
-
-// routeTableOps takes the old and new routes from flatmap.Expand
-// and returns a set of operations that must be performed in order
-// to get to the desired state.
-func routeTableOps(a interface{}, b interface{}) []routeTableOp {
-	// Build up the actual ec2.Route objects
-	oldRoutes := make(map[string]ec2.Route)
-	newRoutes := make(map[string]ec2.Route)
-	for i, raws := range []interface{}{a, b} {
-		result := oldRoutes
-		if i == 1 {
-			result = newRoutes
-		}
-		if raws == nil {
-			continue
-		}
-
-		for _, raw := range raws.([]interface{}) {
-			m := raw.(map[string]interface{})
-			r := ec2.Route{
-				DestinationCidrBlock: m["cidr_block"].(string),
-			}
 	if v, ok := m["gateway_id"]; ok {
-				r.GatewayId = v.(string)
+		buf.WriteString(fmt.Sprintf("%s-", v.(string)))
 	}
+
 	if v, ok := m["instance_id"]; ok {
-				r.InstanceId = v.(string)
+		buf.WriteString(fmt.Sprintf("%s-", v.(string)))
 	}
 
-			result[r.DestinationCidrBlock] = r
+	return hashcode.String(buf.String())
-		}
 }
 
-	// Now, start building up the ops
+// resourceAwsRouteTableStateRefreshFunc returns a resource.StateRefreshFunc that is used to watch
-	ops := make([]routeTableOp, 0, len(newRoutes))
-	for n, r := range newRoutes {
-		op := routeTableOpCreate
-		if oldR, ok := oldRoutes[n]; ok {
-			if reflect.DeepEqual(r, oldR) {
-				// No changes!
-				continue
-			}
-
-			op = routeTableOpReplace
-		}
-
-		ops = append(ops, routeTableOp{
-			Op:    op,
-			Route: r,
-		})
-	}
-
-	// Determine what routes we need to delete
-	for _, op := range ops {
-		delete(oldRoutes, op.Route.DestinationCidrBlock)
-	}
-	for _, r := range oldRoutes {
-		ops = append(ops, routeTableOp{
-			Op:    routeTableOpDelete,
-			Route: r,
-		})
-	}
-
-	return ops
-}
-
-// RouteTableStateRefreshFunc returns a resource.StateRefreshFunc that is used to watch
 // a RouteTable.
-func RouteTableStateRefreshFunc(conn *ec2.EC2, id string) resource.StateRefreshFunc {
+func resourceAwsRouteTableStateRefreshFunc(conn *ec2.EC2, id string) resource.StateRefreshFunc {
 	return func() (interface{}, string, error) {
 		resp, err := conn.DescribeRouteTables([]string{id}, ec2.NewFilter())
 		if err != nil {

builtin/providers/aws/resource_aws_route_table_association.go

@@ -4,77 +4,121 @@ import (
 	"fmt"
 	"log"
 
-	"github.com/hashicorp/terraform/helper/diff"
+	"github.com/hashicorp/terraform/helper/schema"
-	"github.com/hashicorp/terraform/terraform"
 	"github.com/mitchellh/goamz/ec2"
 )
 
-func resource_aws_route_table_association_create(
+func resourceAwsRouteTableAssociation() *schema.Resource {
-	s *terraform.InstanceState,
+	return &schema.Resource{
-	d *terraform.InstanceDiff,
+		Create: resourceAwsRouteTableAssociationCreate,
-	meta interface{}) (*terraform.InstanceState, error) {
+		Read:   resourceAwsRouteTableAssociationRead,
-	p := meta.(*ResourceProvider)
+		Update: resourceAwsRouteTableAssociationUpdate,
-	ec2conn := p.ec2conn
+		Delete: resourceAwsRouteTableAssociationDelete,
-	rs := s.MergeDiff(d)
+
+		Schema: map[string]*schema.Schema{
+			"subnet_id": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"route_table_id": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+			},
+		},
+	}
+}
+
+func resourceAwsRouteTableAssociationCreate(d *schema.ResourceData, meta interface{}) error {
+	ec2conn := meta.(*AWSClient).ec2conn
 
 	log.Printf(
 		"[INFO] Creating route table association: %s => %s",
-		rs.Attributes["subnet_id"],
+		d.Get("subnet_id").(string),
-		rs.Attributes["route_table_id"])
+		d.Get("route_table_id").(string))
+
 	resp, err := ec2conn.AssociateRouteTable(
-		rs.Attributes["route_table_id"],
+		d.Get("route_table_id").(string),
-		rs.Attributes["subnet_id"])
+		d.Get("subnet_id").(string))
+
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	// Set the ID and return
-	rs.ID = resp.AssociationId
+	d.SetId(resp.AssociationId)
-	log.Printf("[INFO] Association ID: %s", rs.ID)
+	log.Printf("[INFO] Association ID: %s", d.Id())
 
-	return rs, nil
+	return nil
 }
 
-func resource_aws_route_table_association_update(
+func resourceAwsRouteTableAssociationRead(d *schema.ResourceData, meta interface{}) error {
-	s *terraform.InstanceState,
+	ec2conn := meta.(*AWSClient).ec2conn
-	d *terraform.InstanceDiff,
+
-	meta interface{}) (*terraform.InstanceState, error) {
+	// Get the routing table that this association belongs to
-	p := meta.(*ResourceProvider)
+	rtRaw, _, err := resourceAwsRouteTableStateRefreshFunc(
-	ec2conn := p.ec2conn
+		ec2conn, d.Get("route_table_id").(string))()
+	if err != nil {
+		return err
+	}
+	if rtRaw == nil {
+		return nil
+	}
+	rt := rtRaw.(*ec2.RouteTable)
+
+	// Inspect that the association exists
+	found := false
+	for _, a := range rt.Associations {
+		if a.AssociationId == d.Id() {
+			found = true
+			d.Set("subnet_id", a.SubnetId)
+			break
+		}
+	}
+
+	if !found {
+		// It seems it doesn't exist anymore, so clear the ID
+		d.SetId("")
+	}
+
+	return nil
+}
+
+func resourceAwsRouteTableAssociationUpdate(d *schema.ResourceData, meta interface{}) error {
+	ec2conn := meta.(*AWSClient).ec2conn
 
-	rs := s.MergeDiff(d)
 	log.Printf(
-		"[INFO] Replacing route table association: %s => %s",
+		"[INFO] Creating route table association: %s => %s",
-		rs.Attributes["subnet_id"],
+		d.Get("subnet_id").(string),
-		rs.Attributes["route_table_id"])
+		d.Get("route_table_id").(string))
+
 	resp, err := ec2conn.ReassociateRouteTable(
-		rs.ID,
+		d.Id(),
-		rs.Attributes["route_table_id"])
+		d.Get("route_table_id").(string))
+
 	if err != nil {
 		ec2err, ok := err.(*ec2.Error)
 		if ok && ec2err.Code == "InvalidAssociationID.NotFound" {
 			// Not found, so just create a new one
-			return resource_aws_route_table_association_create(s, d, meta)
+			return resourceAwsRouteTableAssociationCreate(d, meta)
 		}
 
-		return s, err
+		return err
 	}
 
 	// Update the ID
-	rs.ID = resp.AssociationId
+	d.SetId(resp.AssociationId)
-	log.Printf("[INFO] Association ID: %s", rs.ID)
+	log.Printf("[INFO] Association ID: %s", d.Id())
 
-	return rs, nil
+	return nil
 }
 
-func resource_aws_route_table_association_destroy(
+func resourceAwsRouteTableAssociationDelete(d *schema.ResourceData, meta interface{}) error {
-	s *terraform.InstanceState,
+	ec2conn := meta.(*AWSClient).ec2conn
-	meta interface{}) error {
-	p := meta.(*ResourceProvider)
-	ec2conn := p.ec2conn
 
-	log.Printf("[INFO] Deleting route table association: %s", s.ID)
+	log.Printf("[INFO] Deleting route table association: %s", d.Id())
-	if _, err := ec2conn.DisassociateRouteTable(s.ID); err != nil {
+	if _, err := ec2conn.DisassociateRouteTable(d.Id()); err != nil {
 		ec2err, ok := err.(*ec2.Error)
 		if ok && ec2err.Code == "InvalidAssociationID.NotFound" {
 			return nil
@@ -85,50 +129,3 @@ func resource_aws_route_table_association_destroy(
 
 	return nil
 }
-
-func resource_aws_route_table_association_refresh(
-	s *terraform.InstanceState,
-	meta interface{}) (*terraform.InstanceState, error) {
-	p := meta.(*ResourceProvider)
-	ec2conn := p.ec2conn
-
-	// Get the routing table that this association belongs to
-	rtRaw, _, err := RouteTableStateRefreshFunc(
-		ec2conn, s.Attributes["route_table_id"])()
-	if err != nil {
-		return s, err
-	}
-	if rtRaw == nil {
-		return nil, nil
-	}
-	rt := rtRaw.(*ec2.RouteTable)
-
-	// Inspect that the association exists
-	found := false
-	for _, a := range rt.Associations {
-		if a.AssociationId == s.ID {
-			found = true
-			s.Attributes["subnet_id"] = a.SubnetId
-			break
-		}
-	}
-	if !found {
-		return nil, nil
-	}
-
-	return s, nil
-}
-
-func resource_aws_route_table_association_diff(
-	s *terraform.InstanceState,
-	c *terraform.ResourceConfig,
-	meta interface{}) (*terraform.InstanceDiff, error) {
-	b := &diff.ResourceBuilder{
-		Attrs: map[string]diff.AttrType{
-			"subnet_id":      diff.AttrTypeCreate,
-			"route_table_id": diff.AttrTypeUpdate,
-		},
-	}
-
-	return b.Diff(s, c)
-}

builtin/providers/aws/resource_aws_route_table_association_test.go

@@ -37,7 +37,7 @@ func TestAccAWSRouteTableAssociation(t *testing.T) {
 }
 
 func testAccCheckRouteTableAssociationDestroy(s *terraform.State) error {
-	conn := testAccProvider.ec2conn
+	conn := testAccProvider.Meta().(*AWSClient).ec2conn
 
 	for _, rs := range s.RootModule().Resources {
 		if rs.Type != "aws_route_table_association" {
@@ -81,7 +81,7 @@ func testAccCheckRouteTableAssociationExists(n string, v *ec2.RouteTable) resour
 			return fmt.Errorf("No ID is set")
 		}
 
-		conn := testAccProvider.ec2conn
+		conn := testAccProvider.Meta().(*AWSClient).ec2conn
 		resp, err := conn.DescribeRouteTables(
 			[]string{rs.Primary.Attributes["route_table_id"]}, ec2.NewFilter())
 		if err != nil {

builtin/providers/aws/resource_aws_route_table_test.go

@@ -122,7 +122,7 @@ func TestAccAWSRouteTable_instance(t *testing.T) {
 }
 
 func testAccCheckRouteTableDestroy(s *terraform.State) error {
-	conn := testAccProvider.ec2conn
+	conn := testAccProvider.Meta().(*AWSClient).ec2conn
 
 	for _, rs := range s.RootModule().Resources {
 		if rs.Type != "aws_route_table" {
@@ -164,7 +164,7 @@ func testAccCheckRouteTableExists(n string, v *ec2.RouteTable) resource.TestChec
 			return fmt.Errorf("No ID is set")
 		}
 
-		conn := testAccProvider.ec2conn
+		conn := testAccProvider.Meta().(*AWSClient).ec2conn
 		resp, err := conn.DescribeRouteTables(
 			[]string{rs.Primary.ID}, ec2.NewFilter())
 		if err != nil {

builtin/providers/aws/resource_aws_s3_bucket.go

@@ -4,90 +4,70 @@ import (
 	"fmt"
 	"log"
 
-	"github.com/hashicorp/terraform/helper/config"
+	"github.com/hashicorp/terraform/helper/schema"
-	"github.com/hashicorp/terraform/helper/diff"
-	"github.com/hashicorp/terraform/terraform"
 	"github.com/mitchellh/goamz/s3"
 )
 
-func resource_aws_s3_bucket_validation() *config.Validator {
+func resourceAwsS3Bucket() *schema.Resource {
-	return &config.Validator{
+	return &schema.Resource{
-		Required: []string{
+		Create: resourceAwsS3BucketCreate,
-			"bucket",
+		Read:   resourceAwsS3BucketRead,
+		Delete: resourceAwsS3BucketDelete,
+
+		Schema: map[string]*schema.Schema{
+			"bucket": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"acl": &schema.Schema{
+				Type:     schema.TypeString,
+				Default:  "private",
+				Optional: true,
+				ForceNew: true,
 			},
-		Optional: []string{
-			"acl",
 		},
 	}
 }
 
-func resource_aws_s3_bucket_create(
+func resourceAwsS3BucketCreate(d *schema.ResourceData, meta interface{}) error {
-	s *terraform.InstanceState,
+	s3conn := meta.(*AWSClient).s3conn
-	d *terraform.InstanceDiff,
-	meta interface{}) (*terraform.InstanceState, error) {
-	p := meta.(*ResourceProvider)
-	s3conn := p.s3conn
 
-	// Merge the diff into the state so that we have all the attributes
+	// Get the bucket and acl
-	// properly.
+	bucket := d.Get("bucket").(string)
-	rs := s.MergeDiff(d)
+	acl := d.Get("acl").(string)
-
-	// Get the bucket and optional acl
-	bucket := rs.Attributes["bucket"]
-	acl := "private"
-	if other, ok := rs.Attributes["acl"]; ok {
-		acl = other
-	}
 
 	log.Printf("[DEBUG] S3 bucket create: %s, ACL: %s", bucket, acl)
 	s3Bucket := s3conn.Bucket(bucket)
 	err := s3Bucket.PutBucket(s3.ACL(acl))
 	if err != nil {
-		return nil, fmt.Errorf("Error creating S3 bucket: %s", err)
+		return fmt.Errorf("Error creating S3 bucket: %s", err)
 	}
 
 	// Assign the bucket name as the resource ID
-	rs.ID = bucket
+	d.SetId(bucket)
-	return rs, nil
+
+	return nil
 }
 
-func resource_aws_s3_bucket_destroy(
+func resourceAwsS3BucketRead(d *schema.ResourceData, meta interface{}) error {
-	s *terraform.InstanceState,
+	s3conn := meta.(*AWSClient).s3conn
-	meta interface{}) error {
-	p := meta.(*ResourceProvider)
-	s3conn := p.s3conn
 
-	name := s.Attributes["bucket"]
+	bucket := s3conn.Bucket(d.Id())
-	bucket := s3conn.Bucket(name)
-
-	log.Printf("[DEBUG] S3 Delete Bucket: %s", name)
-	return bucket.DelBucket()
-}
-
-func resource_aws_s3_bucket_refresh(
-	s *terraform.InstanceState,
-	meta interface{}) (*terraform.InstanceState, error) {
-	p := meta.(*ResourceProvider)
-	s3conn := p.s3conn
-
-	bucket := s3conn.Bucket(s.Attributes["bucket"])
 	resp, err := bucket.Head("/")
 	if err != nil {
-		return s, err
+		return err
 	}
 	defer resp.Body.Close()
-	return s, nil
+	return nil
 }
 
-func resource_aws_s3_bucket_diff(
+func resourceAwsS3BucketDelete(d *schema.ResourceData, meta interface{}) error {
-	s *terraform.InstanceState,
+	s3conn := meta.(*AWSClient).s3conn
-	c *terraform.ResourceConfig,
-	meta interface{}) (*terraform.InstanceDiff, error) {
 
-	b := &diff.ResourceBuilder{
+	log.Printf("[DEBUG] S3 Delete Bucket: %s", d.Id())
-		Attrs: map[string]diff.AttrType{
+	bucket := s3conn.Bucket(d.Id())
-			"bucket": diff.AttrTypeCreate,
+
-		},
+	return bucket.DelBucket()
-	}
-	return b.Diff(s, c)
 }

builtin/providers/aws/resource_aws_s3_bucket_test.go

@@ -2,13 +2,17 @@ package aws
 
 import (
 	"fmt"
+	"math/rand"
 	"testing"
+	"time"
 
 	"github.com/hashicorp/terraform/helper/resource"
 	"github.com/hashicorp/terraform/terraform"
 )
 
 func TestAccAWSS3Bucket(t *testing.T) {
+	rand.Seed(time.Now().UnixNano())
+
 	resource.Test(t, resource.TestCase{
 		PreCheck:     func() { testAccPreCheck(t) },
 		Providers:    testAccProviders,
@@ -25,7 +29,7 @@ func TestAccAWSS3Bucket(t *testing.T) {
 }
 
 func testAccCheckAWSS3BucketDestroy(s *terraform.State) error {
-	conn := testAccProvider.s3conn
+	conn := testAccProvider.Meta().(*AWSClient).s3conn
 
 	for _, rs := range s.RootModule().Resources {
 		if rs.Type != "aws_s3_bucket" {
@@ -53,7 +57,7 @@ func testAccCheckAWSS3BucketExists(n string) resource.TestCheckFunc {
 			return fmt.Errorf("No S3 Bucket ID is set")
 		}
 
-		conn := testAccProvider.s3conn
+		conn := testAccProvider.Meta().(*AWSClient).s3conn
 		bucket := conn.Bucket(rs.Primary.ID)
 		resp, err := bucket.Head("/")
 		if err != nil {
@@ -64,9 +68,11 @@ func testAccCheckAWSS3BucketExists(n string) resource.TestCheckFunc {
 	}
 }
 
-const testAccAWSS3BucketConfig = `
+// This needs a bit of randoness as the name can only be
+// used once globally within AWS
+var testAccAWSS3BucketConfig = fmt.Sprintf(`
 resource "aws_s3_bucket" "bar" {
-	bucket = "tf-test-bucket"
+	bucket = "tf-test-bucket-%d"
 	acl = "public-read"
 }
-`
+`, rand.Int())

builtin/providers/aws/resource_aws_security_group.go

@@ -94,46 +94,8 @@ func resourceAwsSecurityGroup() *schema.Resource {
 	}
 }
 
-func resourceAwsSecurityGroupIngressHash(v interface{}) int {
-	var buf bytes.Buffer
-	m := v.(map[string]interface{})
-	buf.WriteString(fmt.Sprintf("%d-", m["from_port"].(int)))
-	buf.WriteString(fmt.Sprintf("%d-", m["to_port"].(int)))
-	buf.WriteString(fmt.Sprintf("%s-", m["protocol"].(string)))
-
-	// We need to make sure to sort the strings below so that we always
-	// generate the same hash code no matter what is in the set.
-	if v, ok := m["cidr_blocks"]; ok {
-		vs := v.([]interface{})
-		s := make([]string, len(vs))
-		for i, raw := range vs {
-			s[i] = raw.(string)
-		}
-		sort.Strings(s)
-
-		for _, v := range s {
-			buf.WriteString(fmt.Sprintf("%s-", v))
-		}
-	}
-	if v, ok := m["security_groups"]; ok {
-		vs := v.(*schema.Set).List()
-		s := make([]string, len(vs))
-		for i, raw := range vs {
-			s[i] = raw.(string)
-		}
-		sort.Strings(s)
-
-		for _, v := range s {
-			buf.WriteString(fmt.Sprintf("%s-", v))
-		}
-	}
-
-	return hashcode.String(buf.String())
-}
-
 func resourceAwsSecurityGroupCreate(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	ec2conn := meta.(*AWSClient).ec2conn
-	ec2conn := p.ec2conn
 
 	securityGroupOpts := ec2.SecurityGroup{
 		Name: d.Get("name").(string),
@@ -177,103 +139,8 @@ func resourceAwsSecurityGroupCreate(d *schema.ResourceData, meta interface{}) er
 	return resourceAwsSecurityGroupUpdate(d, meta)
 }
 
-func resourceAwsSecurityGroupUpdate(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
-	ec2conn := p.ec2conn
-
-	sgRaw, _, err := SGStateRefreshFunc(ec2conn, d.Id())()
-	if err != nil {
-		return err
-	}
-	if sgRaw == nil {
-		d.SetId("")
-		return nil
-	}
-	group := sgRaw.(*ec2.SecurityGroupInfo).SecurityGroup
-
-	if d.HasChange("ingress") {
-		o, n := d.GetChange("ingress")
-		if o == nil {
-			o = new(schema.Set)
-		}
-		if n == nil {
-			n = new(schema.Set)
-		}
-
-		os := o.(*schema.Set)
-		ns := n.(*schema.Set)
-
-		remove := expandIPPerms(d.Id(), os.Difference(ns).List())
-		add := expandIPPerms(d.Id(), ns.Difference(os).List())
-
-		// TODO: We need to handle partial state better in the in-between
-		// in this update.
-
-		// TODO: It'd be nicer to authorize before removing, but then we have
-		// to deal with complicated unrolling to get individual CIDR blocks
-		// to avoid authorizing already authorized sources. Removing before
-		// adding is easier here, and Terraform should be fast enough to
-		// not have service issues.
-
-		if len(remove) > 0 {
-			// Revoke the old rules
-			_, err = ec2conn.RevokeSecurityGroup(group, remove)
-			if err != nil {
-				return fmt.Errorf("Error authorizing security group ingress rules: %s", err)
-			}
-		}
-
-		if len(add) > 0 {
-			// Authorize the new rules
-			_, err := ec2conn.AuthorizeSecurityGroup(group, add)
-			if err != nil {
-				return fmt.Errorf("Error authorizing security group ingress rules: %s", err)
-			}
-		}
-	}
-
-	if err := setTags(ec2conn, d); err != nil {
-		return err
-	} else {
-		d.SetPartial("tags")
-	}
-
-	return nil
-}
-
-func resourceAwsSecurityGroupDelete(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
-	ec2conn := p.ec2conn
-
-	log.Printf("[DEBUG] Security Group destroy: %v", d.Id())
-
-	return resource.Retry(5*time.Minute, func() error {
-		_, err := ec2conn.DeleteSecurityGroup(ec2.SecurityGroup{Id: d.Id()})
-		if err != nil {
-			ec2err, ok := err.(*ec2.Error)
-			if !ok {
-				return err
-			}
-
-			switch ec2err.Code {
-			case "InvalidGroup.NotFound":
-				return nil
-			case "DependencyViolation":
-				// If it is a dependency violation, we want to retry
-				return err
-			default:
-				// Any other error, we want to quit the retry loop immediately
-				return resource.RetryError{err}
-			}
-		}
-
-		return nil
-	})
-}
-
 func resourceAwsSecurityGroupRead(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	ec2conn := meta.(*AWSClient).ec2conn
-	ec2conn := p.ec2conn
 
 	sgRaw, _, err := SGStateRefreshFunc(ec2conn, d.Id())()
 	if err != nil {
@@ -348,6 +215,135 @@ func resourceAwsSecurityGroupRead(d *schema.ResourceData, meta interface{}) erro
 	return nil
 }
 
+func resourceAwsSecurityGroupUpdate(d *schema.ResourceData, meta interface{}) error {
+	ec2conn := meta.(*AWSClient).ec2conn
+
+	sgRaw, _, err := SGStateRefreshFunc(ec2conn, d.Id())()
+	if err != nil {
+		return err
+	}
+	if sgRaw == nil {
+		d.SetId("")
+		return nil
+	}
+	group := sgRaw.(*ec2.SecurityGroupInfo).SecurityGroup
+
+	if d.HasChange("ingress") {
+		o, n := d.GetChange("ingress")
+		if o == nil {
+			o = new(schema.Set)
+		}
+		if n == nil {
+			n = new(schema.Set)
+		}
+
+		os := o.(*schema.Set)
+		ns := n.(*schema.Set)
+
+		remove := expandIPPerms(d.Id(), os.Difference(ns).List())
+		add := expandIPPerms(d.Id(), ns.Difference(os).List())
+
+		// TODO: We need to handle partial state better in the in-between
+		// in this update.
+
+		// TODO: It'd be nicer to authorize before removing, but then we have
+		// to deal with complicated unrolling to get individual CIDR blocks
+		// to avoid authorizing already authorized sources. Removing before
+		// adding is easier here, and Terraform should be fast enough to
+		// not have service issues.
+
+		if len(remove) > 0 {
+			// Revoke the old rules
+			_, err = ec2conn.RevokeSecurityGroup(group, remove)
+			if err != nil {
+				return fmt.Errorf("Error authorizing security group ingress rules: %s", err)
+			}
+		}
+
+		if len(add) > 0 {
+			// Authorize the new rules
+			_, err := ec2conn.AuthorizeSecurityGroup(group, add)
+			if err != nil {
+				return fmt.Errorf("Error authorizing security group ingress rules: %s", err)
+			}
+		}
+	}
+
+	if err := setTags(ec2conn, d); err != nil {
+		return err
+	} else {
+		d.SetPartial("tags")
+	}
+
+	return resourceAwsSecurityGroupRead(d, meta)
+}
+
+func resourceAwsSecurityGroupDelete(d *schema.ResourceData, meta interface{}) error {
+	ec2conn := meta.(*AWSClient).ec2conn
+
+	log.Printf("[DEBUG] Security Group destroy: %v", d.Id())
+
+	return resource.Retry(5*time.Minute, func() error {
+		_, err := ec2conn.DeleteSecurityGroup(ec2.SecurityGroup{Id: d.Id()})
+		if err != nil {
+			ec2err, ok := err.(*ec2.Error)
+			if !ok {
+				return err
+			}
+
+			switch ec2err.Code {
+			case "InvalidGroup.NotFound":
+				return nil
+			case "DependencyViolation":
+				// If it is a dependency violation, we want to retry
+				return err
+			default:
+				// Any other error, we want to quit the retry loop immediately
+				return resource.RetryError{err}
+			}
+		}
+
+		return nil
+	})
+}
+
+func resourceAwsSecurityGroupIngressHash(v interface{}) int {
+	var buf bytes.Buffer
+	m := v.(map[string]interface{})
+	buf.WriteString(fmt.Sprintf("%d-", m["from_port"].(int)))
+	buf.WriteString(fmt.Sprintf("%d-", m["to_port"].(int)))
+	buf.WriteString(fmt.Sprintf("%s-", m["protocol"].(string)))
+
+	// We need to make sure to sort the strings below so that we always
+	// generate the same hash code no matter what is in the set.
+	if v, ok := m["cidr_blocks"]; ok {
+		vs := v.([]interface{})
+		s := make([]string, len(vs))
+		for i, raw := range vs {
+			s[i] = raw.(string)
+		}
+		sort.Strings(s)
+
+		for _, v := range s {
+			buf.WriteString(fmt.Sprintf("%s-", v))
+		}
+	}
+	if v, ok := m["security_groups"]; ok {
+		vs := v.(*schema.Set).List()
+		s := make([]string, len(vs))
+		for i, raw := range vs {
+			s[i] = raw.(string)
+		}
+		sort.Strings(s)
+
+		for _, v := range s {
+			buf.WriteString(fmt.Sprintf("%s-", v))
+		}
+	}
+
+	return hashcode.String(buf.String())
+}
+
 // SGStateRefreshFunc returns a resource.StateRefreshFunc that is used to watch
 // a security group.
 func SGStateRefreshFunc(conn *ec2.EC2, id string) resource.StateRefreshFunc {

builtin/providers/aws/resource_aws_security_group_test.go

@@ -174,7 +174,7 @@ func TestAccAWSSecurityGroup_Change(t *testing.T) {
 }
 
 func testAccCheckAWSSecurityGroupDestroy(s *terraform.State) error {
-	conn := testAccProvider.ec2conn
+	conn := testAccProvider.Meta().(*AWSClient).ec2conn
 
 	for _, rs := range s.RootModule().Resources {
 		if rs.Type != "aws_security_group" {
@@ -221,7 +221,7 @@ func testAccCheckAWSSecurityGroupExists(n string, group *ec2.SecurityGroupInfo)
 			return fmt.Errorf("No Security Group is set")
 		}
 
-		conn := testAccProvider.ec2conn
+		conn := testAccProvider.Meta().(*AWSClient).ec2conn
 		sgs := []ec2.SecurityGroup{
 			ec2.SecurityGroup{
 				Id: rs.Primary.ID,

builtin/providers/aws/resource_aws_subnet.go

@@ -49,8 +49,7 @@ func resourceAwsSubnet() *schema.Resource {
 }
 
 func resourceAwsSubnetCreate(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	ec2conn := meta.(*AWSClient).ec2conn
-	ec2conn := p.ec2conn
 
 	createOpts := &ec2.CreateSubnet{
 		AvailabilityZone: d.Get("availability_zone").(string),
@@ -90,8 +89,7 @@ func resourceAwsSubnetCreate(d *schema.ResourceData, meta interface{}) error {
 }
 
 func resourceAwsSubnetRead(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	ec2conn := meta.(*AWSClient).ec2conn
-	ec2conn := p.ec2conn
 
 	resp, err := ec2conn.DescribeSubnets([]string{d.Id()}, ec2.NewFilter())
 
@@ -114,8 +112,7 @@ func resourceAwsSubnetRead(d *schema.ResourceData, meta interface{}) error {
 }
 
 func resourceAwsSubnetUpdate(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	ec2conn := meta.(*AWSClient).ec2conn
-	ec2conn := p.ec2conn
 
 	d.Partial(true)
 
@@ -148,8 +145,7 @@ func resourceAwsSubnetUpdate(d *schema.ResourceData, meta interface{}) error {
 }
 
 func resourceAwsSubnetDelete(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	ec2conn := meta.(*AWSClient).ec2conn
-	ec2conn := p.ec2conn
 
 	log.Printf("[INFO] Deleting subnet: %s", d.Id())
 	if _, err := ec2conn.DeleteSubnet(d.Id()); err != nil {

builtin/providers/aws/resource_aws_subnet_test.go

@@ -42,7 +42,7 @@ func TestAccAWSSubnet(t *testing.T) {
 }
 
 func testAccCheckSubnetDestroy(s *terraform.State) error {
-	conn := testAccProvider.ec2conn
+	conn := testAccProvider.Meta().(*AWSClient).ec2conn
 
 	for _, rs := range s.RootModule().Resources {
 		if rs.Type != "aws_subnet" {
@@ -84,7 +84,7 @@ func testAccCheckSubnetExists(n string, v *ec2.Subnet) resource.TestCheckFunc {
 			return fmt.Errorf("No ID is set")
 		}
 
-		conn := testAccProvider.ec2conn
+		conn := testAccProvider.Meta().(*AWSClient).ec2conn
 		resp, err := conn.DescribeSubnets(
 			[]string{rs.Primary.ID}, ec2.NewFilter())
 		if err != nil {

builtin/providers/aws/resource_aws_vpc.go

@@ -47,8 +47,7 @@ func resourceAwsVpc() *schema.Resource {
 }
 
 func resourceAwsVpcCreate(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	ec2conn := meta.(*AWSClient).ec2conn
-	ec2conn := p.ec2conn
 
 	// Create the VPC
 	createOpts := &ec2.CreateVpc{
@@ -89,73 +88,8 @@ func resourceAwsVpcCreate(d *schema.ResourceData, meta interface{}) error {
 	return resourceAwsVpcUpdate(d, meta)
 }
 
-func resourceAwsVpcUpdate(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
-	ec2conn := p.ec2conn
-
-	// Turn on partial mode
-	d.Partial(true)
-
-	if d.HasChange("enable_dns_hostnames") {
-		options := new(ec2.ModifyVpcAttribute)
-		options.EnableDnsHostnames = d.Get("enable_dns_hostnames").(bool)
-		options.SetEnableDnsHostnames = true
-
-		log.Printf(
-			"[INFO] Modifying enable_dns_hostnames vpc attribute for %s: %#v",
-			d.Id(), options)
-		if _, err := ec2conn.ModifyVpcAttribute(d.Id(), options); err != nil {
-			return err
-		}
-
-		d.SetPartial("enable_dns_hostnames")
-	}
-
-	if d.HasChange("enable_dns_support") {
-		options := new(ec2.ModifyVpcAttribute)
-		options.EnableDnsSupport = d.Get("enable_dns_support").(bool)
-		options.SetEnableDnsSupport = true
-
-		log.Printf(
-			"[INFO] Modifying enable_dns_support vpc attribute for %s: %#v",
-			d.Id(), options)
-		if _, err := ec2conn.ModifyVpcAttribute(d.Id(), options); err != nil {
-			return err
-		}
-
-		d.SetPartial("enable_dns_support")
-	}
-
-	if err := setTags(ec2conn, d); err != nil {
-		return err
-	} else {
-		d.SetPartial("tags")
-	}
-
-	d.Partial(false)
-	return resourceAwsVpcRead(d, meta)
-}
-
-func resourceAwsVpcDelete(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
-	ec2conn := p.ec2conn
-
-	log.Printf("[INFO] Deleting VPC: %s", d.Id())
-	if _, err := ec2conn.DeleteVpc(d.Id()); err != nil {
-		ec2err, ok := err.(*ec2.Error)
-		if ok && ec2err.Code == "InvalidVpcID.NotFound" {
-			return nil
-		}
-
-		return fmt.Errorf("Error deleting VPC: %s", err)
-	}
-
-	return nil
-}
-
 func resourceAwsVpcRead(d *schema.ResourceData, meta interface{}) error {
-	p := meta.(*ResourceProvider)
+	ec2conn := meta.(*AWSClient).ec2conn
-	ec2conn := p.ec2conn
 
 	// Refresh the VPC state
 	vpcRaw, _, err := VPCStateRefreshFunc(ec2conn, d.Id())()
@@ -201,6 +135,68 @@ func resourceAwsVpcRead(d *schema.ResourceData, meta interface{}) error {
 	return nil
 }
 
+func resourceAwsVpcUpdate(d *schema.ResourceData, meta interface{}) error {
+	ec2conn := meta.(*AWSClient).ec2conn
+
+	// Turn on partial mode
+	d.Partial(true)
+
+	if d.HasChange("enable_dns_hostnames") {
+		options := new(ec2.ModifyVpcAttribute)
+		options.EnableDnsHostnames = d.Get("enable_dns_hostnames").(bool)
+		options.SetEnableDnsHostnames = true
+
+		log.Printf(
+			"[INFO] Modifying enable_dns_hostnames vpc attribute for %s: %#v",
+			d.Id(), options)
+		if _, err := ec2conn.ModifyVpcAttribute(d.Id(), options); err != nil {
+			return err
+		}
+
+		d.SetPartial("enable_dns_hostnames")
+	}
+
+	if d.HasChange("enable_dns_support") {
+		options := new(ec2.ModifyVpcAttribute)
+		options.EnableDnsSupport = d.Get("enable_dns_support").(bool)
+		options.SetEnableDnsSupport = true
+
+		log.Printf(
+			"[INFO] Modifying enable_dns_support vpc attribute for %s: %#v",
+			d.Id(), options)
+		if _, err := ec2conn.ModifyVpcAttribute(d.Id(), options); err != nil {
+			return err
+		}
+
+		d.SetPartial("enable_dns_support")
+	}
+
+	if err := setTags(ec2conn, d); err != nil {
+		return err
+	} else {
+		d.SetPartial("tags")
+	}
+
+	d.Partial(false)
+	return resourceAwsVpcRead(d, meta)
+}
+
+func resourceAwsVpcDelete(d *schema.ResourceData, meta interface{}) error {
+	ec2conn := meta.(*AWSClient).ec2conn
+
+	log.Printf("[INFO] Deleting VPC: %s", d.Id())
+	if _, err := ec2conn.DeleteVpc(d.Id()); err != nil {
+		ec2err, ok := err.(*ec2.Error)
+		if ok && ec2err.Code == "InvalidVpcID.NotFound" {
+			return nil
+		}
+
+		return fmt.Errorf("Error deleting VPC: %s", err)
+	}
+
+	return nil
+}
+
 // VPCStateRefreshFunc returns a resource.StateRefreshFunc that is used to watch
 // a VPC.
 func VPCStateRefreshFunc(conn *ec2.EC2, id string) resource.StateRefreshFunc {

builtin/providers/aws/resource_aws_vpc_test.go

@@ -91,7 +91,7 @@ func TestAccVpcUpdate(t *testing.T) {
 }
 
 func testAccCheckVpcDestroy(s *terraform.State) error {
-	conn := testAccProvider.ec2conn
+	conn := testAccProvider.Meta().(*AWSClient).ec2conn
 
 	for _, rs := range s.RootModule().Resources {
 		if rs.Type != "aws_vpc" {
@@ -142,7 +142,7 @@ func testAccCheckVpcExists(n string, vpc *ec2.VPC) resource.TestCheckFunc {
 			return fmt.Errorf("No VPC ID is set")
 		}
 
-		conn := testAccProvider.ec2conn
+		conn := testAccProvider.Meta().(*AWSClient).ec2conn
 		resp, err := conn.DescribeVpcs([]string{rs.Primary.ID}, ec2.NewFilter())
 		if err != nil {
 			return err

builtin/providers/aws/resource_provider.go

@@ -1,135 +0,0 @@
-package aws
-
-import (
-	"log"
-
-	"github.com/hashicorp/terraform/helper/config"
-	"github.com/hashicorp/terraform/helper/multierror"
-	"github.com/hashicorp/terraform/helper/schema"
-	"github.com/hashicorp/terraform/terraform"
-	"github.com/mitchellh/goamz/autoscaling"
-	"github.com/mitchellh/goamz/ec2"
-	"github.com/mitchellh/goamz/elb"
-	"github.com/mitchellh/goamz/rds"
-	"github.com/mitchellh/goamz/route53"
-	"github.com/mitchellh/goamz/s3"
-)
-
-type ResourceProvider struct {
-	Config Config
-
-	ec2conn         *ec2.EC2
-	elbconn         *elb.ELB
-	autoscalingconn *autoscaling.AutoScaling
-	s3conn          *s3.S3
-	rdsconn         *rds.Rds
-	route53         *route53.Route53
-
-	// This is the schema.Provider. Eventually this will replace much
-	// of this structure. For now it is an element of it for compatiblity.
-	p *schema.Provider
-}
-
-func (p *ResourceProvider) Input(
-	input terraform.UIInput,
-	c *terraform.ResourceConfig) (*terraform.ResourceConfig, error) {
-	return Provider().Input(input, c)
-}
-
-func (p *ResourceProvider) Validate(c *terraform.ResourceConfig) ([]string, []error) {
-	return Provider().Validate(c)
-}
-
-func (p *ResourceProvider) ValidateResource(
-	t string, c *terraform.ResourceConfig) ([]string, []error) {
-	prov := Provider()
-	if _, ok := prov.ResourcesMap[t]; ok {
-		return prov.ValidateResource(t, c)
-	}
-
-	return resourceMap.Validate(t, c)
-}
-
-func (p *ResourceProvider) Configure(c *terraform.ResourceConfig) error {
-	if _, err := config.Decode(&p.Config, c.Config); err != nil {
-		return err
-	}
-
-	// Get the auth and region. This can fail if keys/regions were not
-	// specified and we're attempting to use the environment.
-	var errs []error
-	log.Println("[INFO] Building AWS auth structure")
-	auth, err := p.Config.AWSAuth()
-	if err != nil {
-		errs = append(errs, err)
-	}
-
-	log.Println("[INFO] Building AWS region structure")
-	region, err := p.Config.AWSRegion()
-	if err != nil {
-		errs = append(errs, err)
-	}
-
-	if len(errs) == 0 {
-		log.Println("[INFO] Initializing EC2 connection")
-		p.ec2conn = ec2.New(auth, region)
-		log.Println("[INFO] Initializing ELB connection")
-		p.elbconn = elb.New(auth, region)
-		log.Println("[INFO] Initializing AutoScaling connection")
-		p.autoscalingconn = autoscaling.New(auth, region)
-		log.Println("[INFO] Initializing S3 connection")
-		p.s3conn = s3.New(auth, region)
-		log.Println("[INFO] Initializing RDS connection")
-		p.rdsconn = rds.New(auth, region)
-		log.Println("[INFO] Initializing Route53 connection")
-		p.route53 = route53.New(auth, region)
-	}
-
-	if len(errs) > 0 {
-		return &multierror.Error{Errors: errs}
-	}
-
-	// Create the provider, set the meta
-	p.p = Provider()
-	p.p.SetMeta(p)
-
-	return nil
-}
-
-func (p *ResourceProvider) Apply(
-	info *terraform.InstanceInfo,
-	s *terraform.InstanceState,
-	d *terraform.InstanceDiff) (*terraform.InstanceState, error) {
-	if _, ok := p.p.ResourcesMap[info.Type]; ok {
-		return p.p.Apply(info, s, d)
-	}
-
-	return resourceMap.Apply(info, s, d, p)
-}
-
-func (p *ResourceProvider) Diff(
-	info *terraform.InstanceInfo,
-	s *terraform.InstanceState,
-	c *terraform.ResourceConfig) (*terraform.InstanceDiff, error) {
-	if _, ok := p.p.ResourcesMap[info.Type]; ok {
-		return p.p.Diff(info, s, c)
-	}
-
-	return resourceMap.Diff(info, s, c, p)
-}
-
-func (p *ResourceProvider) Refresh(
-	info *terraform.InstanceInfo,
-	s *terraform.InstanceState) (*terraform.InstanceState, error) {
-	if _, ok := p.p.ResourcesMap[info.Type]; ok {
-		return p.p.Refresh(info, s)
-	}
-
-	return resourceMap.Refresh(info, s, p)
-}
-
-func (p *ResourceProvider) Resources() []terraform.ResourceType {
-	result := resourceMap.Resources()
-	result = append(result, Provider().Resources()...)
-	return result
-}

builtin/providers/aws/resource_provider_test.go

@@ -1,95 +0,0 @@
-package aws
-
-import (
-	"log"
-	"os"
-	"reflect"
-	"testing"
-
-	"github.com/hashicorp/terraform/config"
-	"github.com/hashicorp/terraform/terraform"
-)
-
-var testAccProviders map[string]terraform.ResourceProvider
-var testAccProvider *ResourceProvider
-
-func init() {
-	testAccProvider = new(ResourceProvider)
-	testAccProviders = map[string]terraform.ResourceProvider{
-		"aws": testAccProvider,
-	}
-}
-
-func TestResourceProvider_impl(t *testing.T) {
-	var _ terraform.ResourceProvider = new(ResourceProvider)
-}
-
-func TestResourceProvider_Configure(t *testing.T) {
-	rp := new(ResourceProvider)
-
-	raw := map[string]interface{}{
-		"access_key": "foo",
-		"secret_key": "bar",
-		"region":     "us-east-1",
-	}
-
-	rawConfig, err := config.NewRawConfig(raw)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	err = rp.Configure(terraform.NewResourceConfig(rawConfig))
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	expected := Config{
-		AccessKey: "foo",
-		SecretKey: "bar",
-		Region:    "us-east-1",
-	}
-
-	if !reflect.DeepEqual(rp.Config, expected) {
-		t.Fatalf("bad: %#v", rp.Config)
-	}
-
-	if rp.p == nil {
-		t.Fatal("provider should be set")
-	}
-	if !reflect.DeepEqual(rp, rp.p.Meta()) {
-		t.Fatalf("meta should be set")
-	}
-}
-
-func TestResourceProvider_ConfigureBadRegion(t *testing.T) {
-	rp := new(ResourceProvider)
-
-	raw := map[string]interface{}{
-		"access_key": "foo",
-		"secret_key": "bar",
-		"region":     "blah",
-	}
-
-	rawConfig, err := config.NewRawConfig(raw)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	err = rp.Configure(terraform.NewResourceConfig(rawConfig))
-	if err == nil {
-		t.Fatalf("should have err: bad region")
-	}
-}
-
-func testAccPreCheck(t *testing.T) {
-	if v := os.Getenv("AWS_ACCESS_KEY"); v == "" {
-		t.Fatal("AWS_ACCESS_KEY must be set for acceptance tests")
-	}
-	if v := os.Getenv("AWS_SECRET_KEY"); v == "" {
-		t.Fatal("AWS_SECRET_KEY must be set for acceptance tests")
-	}
-	if v := os.Getenv("AWS_REGION"); v == "" {
-		log.Println("[INFO] Test: Using us-west-2 as test region")
-		os.Setenv("AWS_REGION", "us-west-2")
-	}
-}

builtin/providers/aws/resources.go

@@ -1,98 +0,0 @@
-package aws
-
-import (
-	"github.com/hashicorp/terraform/helper/config"
-	"github.com/hashicorp/terraform/helper/resource"
-)
-
-// resourceMap is the mapping of resources we support to their basic
-// operations. This makes it easy to implement new resource types.
-var resourceMap *resource.Map
-
-func init() {
-	resourceMap = &resource.Map{
-		Mapping: map[string]resource.Resource{
-			"aws_db_instance": resource.Resource{
-				ConfigValidator: resource_aws_db_instance_validation(),
-				Create:          resource_aws_db_instance_create,
-				Destroy:         resource_aws_db_instance_destroy,
-				Diff:            resource_aws_db_instance_diff,
-				Refresh:         resource_aws_db_instance_refresh,
-				Update:          resource_aws_db_instance_update,
-			},
-
-			"aws_db_security_group": resource.Resource{
-				ConfigValidator: resource_aws_db_security_group_validation(),
-				Create:          resource_aws_db_security_group_create,
-				Destroy:         resource_aws_db_security_group_destroy,
-				Diff:            resource_aws_db_security_group_diff,
-				Refresh:         resource_aws_db_security_group_refresh,
-			},
-
-			"aws_internet_gateway": resource.Resource{
-				Create:  resource_aws_internet_gateway_create,
-				Destroy: resource_aws_internet_gateway_destroy,
-				Diff:    resource_aws_internet_gateway_diff,
-				Refresh: resource_aws_internet_gateway_refresh,
-				Update:  resource_aws_internet_gateway_update,
-			},
-
-			"aws_route_table": resource.Resource{
-				ConfigValidator: &config.Validator{
-					Required: []string{
-						"vpc_id",
-					},
-					Optional: []string{
-						"route.*.cidr_block",
-						"route.*.gateway_id",
-						"route.*.instance_id",
-					},
-				},
-				Create:  resource_aws_route_table_create,
-				Destroy: resource_aws_route_table_destroy,
-				Diff:    resource_aws_route_table_diff,
-				Refresh: resource_aws_route_table_refresh,
-				Update:  resource_aws_route_table_update,
-			},
-
-			"aws_route_table_association": resource.Resource{
-				ConfigValidator: &config.Validator{
-					Required: []string{
-						"route_table_id",
-						"subnet_id",
-					},
-				},
-				Create:  resource_aws_route_table_association_create,
-				Destroy: resource_aws_route_table_association_destroy,
-				Diff:    resource_aws_route_table_association_diff,
-				Refresh: resource_aws_route_table_association_refresh,
-				Update:  resource_aws_route_table_association_update,
-			},
-
-			"aws_route53_record": resource.Resource{
-				ConfigValidator: resource_aws_r53_record_validation(),
-				Create:          resource_aws_r53_record_create,
-				Destroy:         resource_aws_r53_record_destroy,
-				Diff:            resource_aws_r53_record_diff,
-				Refresh:         resource_aws_r53_record_refresh,
-				Update:          resource_aws_r53_record_create,
-			},
-
-			"aws_route53_zone": resource.Resource{
-				ConfigValidator: resource_aws_r53_zone_validation(),
-				Create:          resource_aws_r53_zone_create,
-				Destroy:         resource_aws_r53_zone_destroy,
-				Diff:            resource_aws_r53_zone_diff,
-				Refresh:         resource_aws_r53_zone_refresh,
-			},
-
-			"aws_s3_bucket": resource.Resource{
-				ConfigValidator: resource_aws_s3_bucket_validation(),
-				Create:          resource_aws_s3_bucket_create,
-				Destroy:         resource_aws_s3_bucket_destroy,
-				Diff:            resource_aws_s3_bucket_diff,
-				Refresh:         resource_aws_s3_bucket_refresh,
-			},
-		},
-	}
-}