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

     1  package scaleway
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  
     7  	"github.com/hashicorp/terraform/helper/schema"
     8  	"github.com/scaleway/scaleway-cli/pkg/api"
     9  )
    10  
    11  func resourceScalewayServer() *schema.Resource {
    12  	return &schema.Resource{
    13  		Create: resourceScalewayServerCreate,
    14  		Read:   resourceScalewayServerRead,
    15  		Update: resourceScalewayServerUpdate,
    16  		Delete: resourceScalewayServerDelete,
    17  		Schema: map[string]*schema.Schema{
    18  			"name": &schema.Schema{
    19  				Type:     schema.TypeString,
    20  				Required: true,
    21  			},
    22  			"image": &schema.Schema{
    23  				Type:     schema.TypeString,
    24  				Required: true,
    25  				ForceNew: true,
    26  			},
    27  			"type": &schema.Schema{
    28  				Type:     schema.TypeString,
    29  				Required: true,
    30  				ForceNew: true,
    31  			},
    32  			"bootscript": &schema.Schema{
    33  				Type:     schema.TypeString,
    34  				Optional: true,
    35  			},
    36  			"tags": &schema.Schema{
    37  				Type: schema.TypeList,
    38  				Elem: &schema.Schema{
    39  					Type: schema.TypeString,
    40  				},
    41  				Optional: true,
    42  			},
    43  			"ipv4_address_private": &schema.Schema{
    44  				Type:     schema.TypeString,
    45  				Computed: true,
    46  			},
    47  			"ipv4_address_public": &schema.Schema{
    48  				Type:     schema.TypeString,
    49  				Computed: true,
    50  			},
    51  			"state": &schema.Schema{
    52  				Type:     schema.TypeString,
    53  				Optional: true,
    54  				Computed: true,
    55  			},
    56  			"dynamic_ip_required": &schema.Schema{
    57  				Type:     schema.TypeBool,
    58  				Optional: true,
    59  			},
    60  			"state_detail": &schema.Schema{
    61  				Type:     schema.TypeString,
    62  				Computed: true,
    63  			},
    64  		},
    65  	}
    66  }
    67  
    68  func resourceScalewayServerCreate(d *schema.ResourceData, m interface{}) error {
    69  	scaleway := m.(*Client).scaleway
    70  
    71  	image := d.Get("image").(string)
    72  	var server = api.ScalewayServerDefinition{
    73  		Name:         d.Get("name").(string),
    74  		Image:        String(image),
    75  		Organization: scaleway.Organization,
    76  	}
    77  
    78  	server.DynamicIPRequired = Bool(d.Get("dynamic_ip_required").(bool))
    79  	server.CommercialType = d.Get("type").(string)
    80  
    81  	if bootscript, ok := d.GetOk("bootscript"); ok {
    82  		server.Bootscript = String(bootscript.(string))
    83  	}
    84  
    85  	if tags, ok := d.GetOk("tags"); ok {
    86  		server.Tags = tags.([]string)
    87  	}
    88  
    89  	id, err := scaleway.PostServer(server)
    90  	if err != nil {
    91  		return err
    92  	}
    93  
    94  	d.SetId(id)
    95  	if d.Get("state").(string) != "stopped" {
    96  		err = scaleway.PostServerAction(id, "poweron")
    97  		if err != nil {
    98  			return err
    99  		}
   100  
   101  		err = waitForServerState(scaleway, id, "running")
   102  	}
   103  
   104  	if err != nil {
   105  		return err
   106  	}
   107  
   108  	return resourceScalewayServerRead(d, m)
   109  }
   110  
   111  func resourceScalewayServerRead(d *schema.ResourceData, m interface{}) error {
   112  	scaleway := m.(*Client).scaleway
   113  	server, err := scaleway.GetServer(d.Id())
   114  
   115  	if err != nil {
   116  		if serr, ok := err.(api.ScalewayAPIError); ok {
   117  			log.Printf("[DEBUG] Error reading server: %q\n", serr.APIMessage)
   118  
   119  			if serr.StatusCode == 404 {
   120  				d.SetId("")
   121  				return nil
   122  			}
   123  		}
   124  
   125  		return err
   126  	}
   127  
   128  	d.Set("ipv4_address_private", server.PrivateIP)
   129  	d.Set("ipv4_address_public", server.PublicAddress.IP)
   130  	d.Set("state", server.State)
   131  	d.Set("state_detail", server.StateDetail)
   132  
   133  	d.SetConnInfo(map[string]string{
   134  		"type": "ssh",
   135  		"host": server.PublicAddress.IP,
   136  	})
   137  
   138  	return nil
   139  }
   140  
   141  func resourceScalewayServerUpdate(d *schema.ResourceData, m interface{}) error {
   142  	scaleway := m.(*Client).scaleway
   143  
   144  	var req api.ScalewayServerPatchDefinition
   145  
   146  	if d.HasChange("name") {
   147  		name := d.Get("name").(string)
   148  		req.Name = &name
   149  	}
   150  
   151  	if d.HasChange("dynamic_ip_required") {
   152  		req.DynamicIPRequired = Bool(d.Get("dynamic_ip_required").(bool))
   153  	}
   154  
   155  	if err := scaleway.PatchServer(d.Id(), req); err != nil {
   156  		return fmt.Errorf("Failed patching scaleway server: %q", err)
   157  	}
   158  
   159  	return resourceScalewayServerRead(d, m)
   160  }
   161  
   162  func resourceScalewayServerDelete(d *schema.ResourceData, m interface{}) error {
   163  	scaleway := m.(*Client).scaleway
   164  
   165  	def, err := scaleway.GetServer(d.Id())
   166  	if err != nil {
   167  		if serr, ok := err.(api.ScalewayAPIError); ok {
   168  			if serr.StatusCode == 404 {
   169  				d.SetId("")
   170  				return nil
   171  			}
   172  		}
   173  		return err
   174  	}
   175  
   176  	err = deleteServerSafe(scaleway, def.Identifier)
   177  	if err != nil {
   178  		return err
   179  	}
   180  
   181  	d.SetId("")
   182  	return nil
   183  }