github.com/koding/terraform@v0.6.4-0.20170608090606-5d7e0339779d/builtin/providers/datadog/resource_datadog_user.go (about)

     1  package datadog
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  	"strings"
     7  
     8  	"github.com/hashicorp/terraform/helper/schema"
     9  	"gopkg.in/zorkian/go-datadog-api.v2"
    10  )
    11  
    12  func resourceDatadogUser() *schema.Resource {
    13  	return &schema.Resource{
    14  		Create: resourceDatadogUserCreate,
    15  		Read:   resourceDatadogUserRead,
    16  		Update: resourceDatadogUserUpdate,
    17  		Delete: resourceDatadogUserDelete,
    18  		Exists: resourceDatadogUserExists,
    19  		Importer: &schema.ResourceImporter{
    20  			State: resourceDatadogUserImport,
    21  		},
    22  
    23  		Schema: map[string]*schema.Schema{
    24  			"disabled": {
    25  				Type:     schema.TypeBool,
    26  				Optional: true,
    27  				Default:  false,
    28  			},
    29  			"email": {
    30  				Type:     schema.TypeString,
    31  				Required: true,
    32  			},
    33  			"handle": {
    34  				Type:     schema.TypeString,
    35  				Required: true,
    36  			},
    37  			"is_admin": {
    38  				Type:     schema.TypeBool,
    39  				Optional: true,
    40  				Default:  false,
    41  			},
    42  			"name": {
    43  				Type:     schema.TypeString,
    44  				Required: true,
    45  			},
    46  			"role": {
    47  				Type:     schema.TypeString,
    48  				Optional: true,
    49  			},
    50  			"verified": {
    51  				Type:     schema.TypeBool,
    52  				Computed: true,
    53  			},
    54  		},
    55  	}
    56  }
    57  
    58  func resourceDatadogUserExists(d *schema.ResourceData, meta interface{}) (b bool, e error) {
    59  	// Exists - This is called to verify a resource still exists. It is called prior to Read,
    60  	// and lowers the burden of Read to be able to assume the resource exists.
    61  	client := meta.(*datadog.Client)
    62  
    63  	if _, err := client.GetUser(d.Id()); err != nil {
    64  		if strings.Contains(err.Error(), "404 Not Found") {
    65  			return false, nil
    66  		}
    67  		return false, err
    68  	}
    69  
    70  	return true, nil
    71  }
    72  
    73  func resourceDatadogUserCreate(d *schema.ResourceData, meta interface{}) error {
    74  	client := meta.(*datadog.Client)
    75  
    76  	var u datadog.User
    77  	u.SetDisabled(d.Get("disabled").(bool))
    78  	u.SetEmail(d.Get("email").(string))
    79  	u.SetHandle(d.Get("handle").(string))
    80  	u.SetIsAdmin(d.Get("is_admin").(bool))
    81  	u.SetName(d.Get("name").(string))
    82  	u.SetRole(d.Get("role").(string))
    83  
    84  	// Datadog does not actually delete users, so CreateUser might return a 409.
    85  	// We ignore that case and proceed, likely re-enabling the user.
    86  	if _, err := client.CreateUser(u.Handle, u.Name); err != nil {
    87  		if !strings.Contains(err.Error(), "API error 409 Conflict") {
    88  			return fmt.Errorf("error creating user: %s", err.Error())
    89  		}
    90  		log.Printf("[INFO] Updating existing Datadog user %q", u.Handle)
    91  	}
    92  
    93  	if err := client.UpdateUser(u); err != nil {
    94  		return fmt.Errorf("error creating user: %s", err.Error())
    95  	}
    96  
    97  	d.SetId(u.GetHandle())
    98  
    99  	return resourceDatadogUserRead(d, meta)
   100  }
   101  
   102  func resourceDatadogUserRead(d *schema.ResourceData, meta interface{}) error {
   103  	client := meta.(*datadog.Client)
   104  
   105  	u, err := client.GetUser(d.Id())
   106  	if err != nil {
   107  		return err
   108  	}
   109  
   110  	d.Set("disabled", u.GetDisabled())
   111  	d.Set("email", u.GetEmail())
   112  	d.Set("handle", u.GetHandle())
   113  	d.Set("is_admin", u.GetIsAdmin())
   114  	d.Set("name", u.GetName())
   115  	d.Set("role", u.GetRole())
   116  	d.Set("verified", u.GetVerified())
   117  
   118  	return nil
   119  }
   120  
   121  func resourceDatadogUserUpdate(d *schema.ResourceData, meta interface{}) error {
   122  	client := meta.(*datadog.Client)
   123  	var u datadog.User
   124  	u.SetDisabled(d.Get("disabled").(bool))
   125  	u.SetEmail(d.Get("email").(string))
   126  	u.SetHandle(d.Id())
   127  	u.SetIsAdmin(d.Get("is_admin").(bool))
   128  	u.SetName(d.Get("name").(string))
   129  	u.SetRole(d.Get("role").(string))
   130  
   131  	if err := client.UpdateUser(u); err != nil {
   132  		return fmt.Errorf("error updating user: %s", err.Error())
   133  	}
   134  
   135  	return resourceDatadogUserRead(d, meta)
   136  }
   137  
   138  func resourceDatadogUserDelete(d *schema.ResourceData, meta interface{}) error {
   139  	client := meta.(*datadog.Client)
   140  
   141  	// Datadog does not actually delete users, but instead marks them as disabled.
   142  	// Bypass DeleteUser if GetUser returns User.Disabled == true, otherwise it will 400.
   143  	if u, err := client.GetUser(d.Id()); err == nil && u.GetDisabled() {
   144  		return nil
   145  	}
   146  
   147  	if err := client.DeleteUser(d.Id()); err != nil {
   148  		return err
   149  	}
   150  
   151  	return nil
   152  }
   153  
   154  func resourceDatadogUserImport(d *schema.ResourceData, meta interface{}) ([]*schema.ResourceData, error) {
   155  	if err := resourceDatadogUserRead(d, meta); err != nil {
   156  		return nil, err
   157  	}
   158  	return []*schema.ResourceData{d}, nil
   159  }