github.com/IBM-Cloud/terraform@v0.6.4-0.20170726051544-8872b87621df/builtin/providers/google/resource_sql_user.go (about)

     1  package google
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  
     7  	"github.com/hashicorp/terraform/helper/schema"
     8  
     9  	"google.golang.org/api/sqladmin/v1beta4"
    10  )
    11  
    12  func resourceSqlUser() *schema.Resource {
    13  	return &schema.Resource{
    14  		Create: resourceSqlUserCreate,
    15  		Read:   resourceSqlUserRead,
    16  		Update: resourceSqlUserUpdate,
    17  		Delete: resourceSqlUserDelete,
    18  
    19  		Schema: map[string]*schema.Schema{
    20  			"host": &schema.Schema{
    21  				Type:     schema.TypeString,
    22  				Required: true,
    23  				ForceNew: true,
    24  			},
    25  
    26  			"instance": &schema.Schema{
    27  				Type:     schema.TypeString,
    28  				Required: true,
    29  				ForceNew: true,
    30  			},
    31  
    32  			"name": &schema.Schema{
    33  				Type:     schema.TypeString,
    34  				Required: true,
    35  				ForceNew: true,
    36  			},
    37  
    38  			"password": &schema.Schema{
    39  				Type:     schema.TypeString,
    40  				Required: true,
    41  			},
    42  
    43  			"project": &schema.Schema{
    44  				Type:     schema.TypeString,
    45  				Optional: true,
    46  				ForceNew: true,
    47  			},
    48  		},
    49  	}
    50  }
    51  
    52  func resourceSqlUserCreate(d *schema.ResourceData, meta interface{}) error {
    53  	config := meta.(*Config)
    54  
    55  	project, err := getProject(d, config)
    56  	if err != nil {
    57  		return err
    58  	}
    59  
    60  	name := d.Get("name").(string)
    61  	instance := d.Get("instance").(string)
    62  	password := d.Get("password").(string)
    63  	host := d.Get("host").(string)
    64  
    65  	user := &sqladmin.User{
    66  		Name:     name,
    67  		Instance: instance,
    68  		Password: password,
    69  		Host:     host,
    70  	}
    71  
    72  	op, err := config.clientSqlAdmin.Users.Insert(project, instance,
    73  		user).Do()
    74  
    75  	if err != nil {
    76  		return fmt.Errorf("Error, failed to insert "+
    77  			"user %s into instance %s: %s", name, instance, err)
    78  	}
    79  
    80  	err = sqladminOperationWait(config, op, "Insert User")
    81  
    82  	if err != nil {
    83  		return fmt.Errorf("Error, failure waiting for insertion of %s "+
    84  			"into %s: %s", name, instance, err)
    85  	}
    86  
    87  	return resourceSqlUserRead(d, meta)
    88  }
    89  
    90  func resourceSqlUserRead(d *schema.ResourceData, meta interface{}) error {
    91  	config := meta.(*Config)
    92  
    93  	project, err := getProject(d, config)
    94  	if err != nil {
    95  		return err
    96  	}
    97  
    98  	name := d.Get("name").(string)
    99  	instance := d.Get("instance").(string)
   100  
   101  	users, err := config.clientSqlAdmin.Users.List(project, instance).Do()
   102  
   103  	if err != nil {
   104  		return handleNotFoundError(err, d, fmt.Sprintf("SQL User %q in instance %q", name, instance))
   105  	}
   106  
   107  	found := false
   108  	for _, user := range users.Items {
   109  		if user.Name == name {
   110  			found = true
   111  			break
   112  		}
   113  	}
   114  
   115  	if !found {
   116  		log.Printf("[WARN] Removing SQL User %q because it's gone", d.Get("name").(string))
   117  		d.SetId("")
   118  
   119  		return nil
   120  	}
   121  
   122  	d.SetId(name)
   123  
   124  	return nil
   125  }
   126  
   127  func resourceSqlUserUpdate(d *schema.ResourceData, meta interface{}) error {
   128  	config := meta.(*Config)
   129  
   130  	if d.HasChange("password") {
   131  		project, err := getProject(d, config)
   132  		if err != nil {
   133  			return err
   134  		}
   135  
   136  		name := d.Get("name").(string)
   137  		instance := d.Get("instance").(string)
   138  		host := d.Get("host").(string)
   139  		password := d.Get("password").(string)
   140  
   141  		user := &sqladmin.User{
   142  			Name:     name,
   143  			Instance: instance,
   144  			Password: password,
   145  			Host:     host,
   146  		}
   147  
   148  		op, err := config.clientSqlAdmin.Users.Update(project, instance, host, name,
   149  			user).Do()
   150  
   151  		if err != nil {
   152  			return fmt.Errorf("Error, failed to update"+
   153  				"user %s into user %s: %s", name, instance, err)
   154  		}
   155  
   156  		err = sqladminOperationWait(config, op, "Insert User")
   157  
   158  		if err != nil {
   159  			return fmt.Errorf("Error, failure waiting for update of %s "+
   160  				"in %s: %s", name, instance, err)
   161  		}
   162  
   163  		return resourceSqlUserRead(d, meta)
   164  	}
   165  
   166  	return nil
   167  }
   168  
   169  func resourceSqlUserDelete(d *schema.ResourceData, meta interface{}) error {
   170  	config := meta.(*Config)
   171  
   172  	project, err := getProject(d, config)
   173  	if err != nil {
   174  		return err
   175  	}
   176  
   177  	name := d.Get("name").(string)
   178  	instance := d.Get("instance").(string)
   179  	host := d.Get("host").(string)
   180  
   181  	op, err := config.clientSqlAdmin.Users.Delete(project, instance, host, name).Do()
   182  
   183  	if err != nil {
   184  		return fmt.Errorf("Error, failed to delete"+
   185  			"user %s in instance %s: %s", name,
   186  			instance, err)
   187  	}
   188  
   189  	err = sqladminOperationWait(config, op, "Delete User")
   190  
   191  	if err != nil {
   192  		return fmt.Errorf("Error, failure waiting for deletion of %s "+
   193  			"in %s: %s", name, instance, err)
   194  	}
   195  
   196  	return nil
   197  }