diff --git a/builtin/providers/packet/resource_packet_ip_address.go b/builtin/providers/packet/resource_packet_ip_address.go new file mode 100644 index 0000000000..c3d2c9815f --- /dev/null +++ b/builtin/providers/packet/resource_packet_ip_address.go @@ -0,0 +1,130 @@ +package packet + +import ( + "github.com/hashicorp/terraform/helper/schema" + "github.com/packethost/packngo" +) + +func resourcePacketIPAddress() *schema.Resource { + return &schema.Resource{ + Create: resourcePacketIPAddressCreate, + Read: resourcePacketIPAddressRead, + Delete: resourcePacketIPAddressDelete, + + Schema: map[string]*schema.Schema{ + "address": &schema.Schema{ + Type: schema.TypeString, + Required: true, + Optional: true, + Computed: true, + }, + + "gateway": &schema.Schema{ + Type: schema.TypeString, + Computed: true, + }, + + "network": &schema.Schema{ + Type: schema.TypeString, + Computed: true, + }, + + "family": &schema.Schema{ + Type: schema.TypeInt, + Computed: true, + }, + + "netmask": &schema.Schema{ + Type: schema.TypeInt, + Computed: true, + }, + + "cidr": &schema.Schema{ + Type: schema.TypeInt, + Computed: true, + }, + + "public": &schema.Schema{ + Type: schema.TypeBool, + Computed: true, + }, + + "assigned_to": &schema.Schema{ + Type: schema.TypeBool, + Computed: true, + }, + + "created": &schema.Schema{ + Type: schema.TypeString, + Computed: true, + }, + + "updated": &schema.Schema{ + Type: schema.TypeString, + Computed: true, + }, + }, + } +} + +func resourcePacketIPAddressCreate(d *schema.ResourceData, meta interface{}) error { + client := meta.(*packngo.Client) + + createRequest := &packngo.IPAddressAssignRequest{ + Address: d.Get("address").(string), + } + + device_id := "" + if attr, ok := d.GetOk("instance_id"); ok { + device_id = attr.(string) + } + + newIPAddress, _, err := client.Ips.Assign(device_id, createRequest) + if err != nil { + return friendlyError(err) + } + + d.SetId(newIPAddress.ID) + + return resourcePacketIPAddressRead(d, meta) +} + +func resourcePacketIPAddressRead(d *schema.ResourceData, meta interface{}) error { + client := meta.(*packngo.Client) + + ip_address, _, err := client.Ips.Get(d.Id()) + if err != nil { + err = friendlyError(err) + + // If the volume somehow already destroyed, mark as succesfully gone. + if isNotFound(err) { + d.SetId("") + return nil + } + + return err + } + + d.Set("address", ip_address.Address) + d.Set("gateway", ip_address.Gateway) + d.Set("network", ip_address.Network) + d.Set("family", ip_address.AddressFamily) + d.Set("netmask", ip_address.Netmask) + d.Set("public", ip_address.Public) + d.Set("cidr", ip_address.Cidr) + d.Set("assigned_to", ip_address.AssignedTo) + d.Set("created", ip_address.Created) + d.Set("updated", ip_address.Updated) + + return nil +} + +func resourcePacketIPAddressDelete(d *schema.ResourceData, meta interface{}) error { + client := meta.(*packngo.Client) + + if _, err := client.Ips.Unassign(d.Id()); err != nil { + return friendlyError(err) + } + + return nil +} diff --git a/builtin/providers/packet/resource_packet_ip_address_test.go b/builtin/providers/packet/resource_packet_ip_address_test.go new file mode 100644 index 0000000000..9944eb107c --- /dev/null +++ b/builtin/providers/packet/resource_packet_ip_address_test.go @@ -0,0 +1,86 @@ +package packet + +import ( + "fmt" + "testing" + + "github.com/hashicorp/terraform/helper/resource" + "github.com/hashicorp/terraform/terraform" + "github.com/packethost/packngo" +) + +func TestAccPacketIPAddress_Basic(t *testing.T) { + var ip_address packngo.IPAddress + + resource.Test(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckPacketIPAddressDestroy, + Steps: []resource.TestStep{ + resource.TestStep{ + Config: testAccCheckPacketIPAddressConfig_basic, + Check: resource.ComposeTestCheckFunc( + testAccCheckPacketIPAddressExists("packet_ip_address.foobar", &ip_address), + testAccCheckPacketIPAddressAttributes(&ip_address), + resource.TestCheckResourceAttr( + "packet_ip_address.foobar", "address", "foobar"), + ), + }, + }, + }) +} + +func testAccCheckPacketIPAddressDestroy(s *terraform.State) error { + client := testAccProvider.Meta().(*packngo.Client) + + for _, rs := range s.RootModule().Resources { + if rs.Type != "packet_ip_address" { + continue + } + if _, _, err := client.Ips.Get(rs.Primary.ID); err == nil { + return fmt.Errorf("IPAddress cstill exists") + } + } + + return nil +} + +func testAccCheckPacketIPAddressAttributes(ip_address *packngo.IPAddress) resource.TestCheckFunc { + return func(s *terraform.State) error { + if ip_address.Address != "foobar" { + return fmt.Errorf("Bad address: %s", ip_address.Address) + } + return nil + } +} + +func testAccCheckPacketIPAddressExists(n string, ip_address *packngo.IPAddress) resource.TestCheckFunc { + return func(s *terraform.State) error { + rs, ok := s.RootModule().Resources[n] + if !ok { + return fmt.Errorf("Not found: %s", n) + } + if rs.Primary.ID == "" { + return fmt.Errorf("No Record ID is set") + } + + client := testAccProvider.Meta().(*packngo.Client) + + foundIPAddress, _, err := client.Ips.Get(rs.Primary.ID) + if err != nil { + return err + } + if foundIPAddress.ID != rs.Primary.ID { + return fmt.Errorf("Record not found: %v - %v", rs.Primary.ID, foundIPAddress) + } + + *ip_address = *foundIPAddress + + return nil + } +} + +var testAccCheckPacketIPAddressConfig_basic = fmt.Sprintf(` +resource "packet_ip_address" "foobar" { + address = "foobar" +}`) diff --git a/builtin/providers/packet/resource_packet_volume.go b/builtin/providers/packet/resource_packet_volume.go index f17f03c4f9..0b121557c3 100644 --- a/builtin/providers/packet/resource_packet_volume.go +++ b/builtin/providers/packet/resource_packet_volume.go @@ -152,7 +152,7 @@ func resourcePacketVolumeCreate(d *schema.ResourceData, meta interface{}) error func resourcePacketVolumeRead(d *schema.ResourceData, meta interface{}) error { client := meta.(*packngo.Client) - device, _, err := client.Volumes.Get(d.Id()) + volume, _, err := client.Volumes.Get(d.Id()) if err != nil { err = friendlyError(err) @@ -165,25 +165,25 @@ func resourcePacketVolumeRead(d *schema.ResourceData, meta interface{}) error { return err } - d.Set("name", device.Name) - d.Set("description", device.Description) - d.Set("size", device.Size) - d.Set("plan", device.Plan.Slug) - d.Set("facility", device.Facility.Code) - d.Set("state", device.State) - d.Set("billing_cycle", device.BillingCycle) - d.Set("locked", device.Locked) - d.Set("created", device.Created) - d.Set("updated", device.Updated) - - snapshot_policies := make([]*packngo.SnapshotPolicy, 0, len(device.SnapshotPolicies)) - for _, snapshot_policy := range device.SnapshotPolicies { + d.Set("name", volume.Name) + d.Set("description", volume.Description) + d.Set("size", volume.Size) + d.Set("plan", volume.Plan.Slug) + d.Set("facility", volume.Facility.Code) + d.Set("state", volume.State) + d.Set("billing_cycle", volume.BillingCycle) + d.Set("locked", volume.Locked) + d.Set("created", volume.Created) + d.Set("updated", volume.Updated) + + snapshot_policies := make([]*packngo.SnapshotPolicy, 0, len(volume.SnapshotPolicies)) + for _, snapshot_policy := range volume.SnapshotPolicies { snapshot_policies = append(snapshot_policies, snapshot_policy) } d.Set("snapshot_policies", snapshot_policies) - attachments := make([]*packngo.Attachment, 0, len(device.Attachments)) - for _, attachment := range device.Attachments { + attachments := make([]*packngo.Attachment, 0, len(volume.Attachments)) + for _, attachment := range volume.Attachments { attachments = append(attachments, attachment) } d.Set("attachments", attachments) diff --git a/vendor/github.com/packethost/packngo/ip.go b/vendor/github.com/packethost/packngo/ip.go index 2a71b921ca..c95147a9a8 100644 --- a/vendor/github.com/packethost/packngo/ip.go +++ b/vendor/github.com/packethost/packngo/ip.go @@ -22,6 +22,8 @@ type IPAddress struct { Public bool `json:"public"` Cidr int `json:"cidr"` AssignedTo map[string]string `json:"assigned_to"` + Created string `json:"created_at,omitempty"` + Updated string `json:"updated_at,omitempty"` Href string `json:"href"` }