2015-10-27 11:04:19 +01:00
|
|
|
package postgresql
|
|
|
|
|
|
|
|
import (
|
|
|
|
"database/sql"
|
|
|
|
"fmt"
|
|
|
|
"strings"
|
|
|
|
|
2016-09-05 23:46:40 +02:00
|
|
|
"github.com/hashicorp/errwrap"
|
2015-10-27 11:04:19 +01:00
|
|
|
"github.com/hashicorp/terraform/helper/schema"
|
|
|
|
"github.com/lib/pq"
|
|
|
|
)
|
|
|
|
|
2016-09-06 00:04:48 +02:00
|
|
|
func resourcePostgreSQLDatabase() *schema.Resource {
|
2015-10-27 11:04:19 +01:00
|
|
|
return &schema.Resource{
|
2016-09-06 00:04:48 +02:00
|
|
|
Create: resourcePostgreSQLDatabaseCreate,
|
|
|
|
Read: resourcePostgreSQLDatabaseRead,
|
|
|
|
Update: resourcePostgreSQLDatabaseUpdate,
|
|
|
|
Delete: resourcePostgreSQLDatabaseDelete,
|
2015-10-27 11:04:19 +01:00
|
|
|
|
|
|
|
Schema: map[string]*schema.Schema{
|
2016-09-05 23:46:40 +02:00
|
|
|
"name": {
|
2016-09-06 08:37:39 +02:00
|
|
|
Type: schema.TypeString,
|
|
|
|
Required: true,
|
|
|
|
Description: "The PostgreSQL database name to connect to",
|
2015-10-27 11:04:19 +01:00
|
|
|
},
|
2016-09-05 23:46:40 +02:00
|
|
|
"owner": {
|
2016-09-06 08:37:39 +02:00
|
|
|
Type: schema.TypeString,
|
|
|
|
Optional: true,
|
|
|
|
Description: "The role name of the user who will own the new database",
|
2015-10-27 11:04:19 +01:00
|
|
|
},
|
2016-09-06 03:40:35 +02:00
|
|
|
"template": {
|
|
|
|
Type: schema.TypeString,
|
|
|
|
Optional: true,
|
|
|
|
Description: "The name of the template from which to create the new database.",
|
|
|
|
},
|
|
|
|
"encoding": {
|
|
|
|
Type: schema.TypeString,
|
|
|
|
Optional: true,
|
|
|
|
Description: "Character set encoding to use in the new database.",
|
|
|
|
},
|
|
|
|
"lc_collate": {
|
|
|
|
Type: schema.TypeString,
|
|
|
|
Optional: true,
|
|
|
|
Description: "Collation order (LC_COLLATE) to use in the new database.",
|
|
|
|
},
|
|
|
|
"lc_ctype": {
|
|
|
|
Type: schema.TypeString,
|
|
|
|
Optional: true,
|
|
|
|
Description: "Character classification (LC_CTYPE) to use in the new database.",
|
|
|
|
},
|
|
|
|
"tablespace_name": {
|
|
|
|
Type: schema.TypeString,
|
|
|
|
Optional: true,
|
|
|
|
Description: "The name of the tablespace that will be associated with the new database.",
|
|
|
|
},
|
|
|
|
"connection_limit": {
|
2016-09-06 08:39:22 +02:00
|
|
|
Type: schema.TypeInt,
|
|
|
|
Optional: true,
|
|
|
|
Computed: true,
|
|
|
|
Description: "How many concurrent connections can be made to this database",
|
|
|
|
ValidateFunc: validateConnLimit,
|
2016-09-06 03:40:35 +02:00
|
|
|
},
|
|
|
|
"allow_connections": {
|
|
|
|
Type: schema.TypeBool,
|
|
|
|
Optional: true,
|
|
|
|
Default: true,
|
|
|
|
Description: "If false then no one can connect to this database.",
|
|
|
|
},
|
|
|
|
"is_template": {
|
|
|
|
Type: schema.TypeBool,
|
|
|
|
Optional: true,
|
|
|
|
Default: false,
|
|
|
|
Description: "If true, then this database can be cloned by any user with CREATEDB privileges.",
|
|
|
|
},
|
2015-10-27 11:04:19 +01:00
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-06 08:39:22 +02:00
|
|
|
func validateConnLimit(v interface{}, key string) (warnings []string, errors []error) {
|
|
|
|
value := v.(int)
|
|
|
|
if value < -1 {
|
|
|
|
errors = append(errors, fmt.Errorf("%d can not be less than -1", key))
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2016-09-06 00:04:48 +02:00
|
|
|
func resourcePostgreSQLDatabaseCreate(d *schema.ResourceData, meta interface{}) error {
|
2015-10-27 11:04:19 +01:00
|
|
|
client := meta.(*Client)
|
|
|
|
conn, err := client.Connect()
|
|
|
|
if err != nil {
|
2016-09-05 23:46:40 +02:00
|
|
|
return errwrap.Wrapf("Error connecting to PostgreSQL: {{err}}", err)
|
2015-10-27 11:04:19 +01:00
|
|
|
}
|
|
|
|
defer conn.Close()
|
|
|
|
|
|
|
|
connUsername := client.username
|
|
|
|
|
2016-09-06 03:40:35 +02:00
|
|
|
const numOptions = 9
|
|
|
|
createOpts := make([]string, 0, numOptions)
|
|
|
|
|
|
|
|
stringOpts := []struct {
|
|
|
|
hclKey string
|
|
|
|
sqlKey string
|
|
|
|
}{
|
|
|
|
{"owner", "OWNER"},
|
|
|
|
{"template", "TEMPLATE"},
|
|
|
|
{"encoding", "ENCODING"},
|
|
|
|
{"lc_collate", "LC_COLLATE"},
|
|
|
|
{"lc_ctype", "LC_CTYPE"},
|
|
|
|
{"tablespace_name", "TABLESPACE"},
|
2015-10-27 11:04:19 +01:00
|
|
|
}
|
2016-09-06 03:40:35 +02:00
|
|
|
for _, opt := range stringOpts {
|
|
|
|
v, ok := d.GetOk(opt.hclKey)
|
|
|
|
var val string
|
|
|
|
if !ok {
|
|
|
|
// Set the owner to the connection username
|
|
|
|
if opt.hclKey == "owner" && v.(string) == "" {
|
|
|
|
val = connUsername
|
|
|
|
} else {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
}
|
2015-10-27 11:04:19 +01:00
|
|
|
|
2016-09-06 03:40:35 +02:00
|
|
|
val = v.(string)
|
|
|
|
|
|
|
|
// Set the owner to the connection username
|
|
|
|
if opt.hclKey == "owner" && val == "" {
|
|
|
|
val = connUsername
|
|
|
|
}
|
|
|
|
|
|
|
|
if val != "" {
|
|
|
|
createOpts = append(createOpts, fmt.Sprintf("%s=%s", opt.sqlKey, pq.QuoteIdentifier(val)))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
intOpts := []struct {
|
|
|
|
hclKey string
|
|
|
|
sqlKey string
|
|
|
|
}{
|
|
|
|
{"connection_limit", "CONNECTION LIMIT"},
|
|
|
|
}
|
|
|
|
for _, opt := range intOpts {
|
|
|
|
v, ok := d.GetOk(opt.hclKey)
|
|
|
|
if !ok {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
val := v.(int)
|
|
|
|
createOpts = append(createOpts, fmt.Sprintf("%s=%d", opt.sqlKey, val))
|
2015-10-27 11:04:19 +01:00
|
|
|
}
|
|
|
|
|
2016-09-06 03:40:35 +02:00
|
|
|
boolOpts := []struct {
|
|
|
|
hclKey string
|
|
|
|
sqlKey string
|
|
|
|
}{
|
|
|
|
{"allow_connections", "ALLOW_CONNECTIONS"},
|
|
|
|
{"is_template", "IS_TEMPLATE"},
|
|
|
|
}
|
|
|
|
for _, opt := range boolOpts {
|
|
|
|
v, ok := d.GetOk(opt.hclKey)
|
|
|
|
if !ok {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
val := v.(bool)
|
|
|
|
createOpts = append(createOpts, fmt.Sprintf("%s=%t", opt.sqlKey, val))
|
|
|
|
}
|
|
|
|
|
|
|
|
dbName := d.Get("name").(string)
|
|
|
|
createStr := strings.Join(createOpts, " ")
|
|
|
|
if len(createOpts) > 0 {
|
|
|
|
createStr = " WITH " + createStr
|
|
|
|
}
|
|
|
|
query := fmt.Sprintf("CREATE DATABASE %s%s", pq.QuoteIdentifier(dbName), createStr)
|
2015-10-27 11:04:19 +01:00
|
|
|
_, err = conn.Query(query)
|
|
|
|
if err != nil {
|
2016-09-06 00:04:48 +02:00
|
|
|
return errwrap.Wrapf(fmt.Sprintf("Error creating database %s: {{err}}", dbName), err)
|
2015-10-27 11:04:19 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
d.SetId(dbName)
|
|
|
|
|
2016-09-06 00:04:48 +02:00
|
|
|
return resourcePostgreSQLDatabaseRead(d, meta)
|
2015-10-27 11:04:19 +01:00
|
|
|
}
|
|
|
|
|
2016-09-06 00:04:48 +02:00
|
|
|
func resourcePostgreSQLDatabaseDelete(d *schema.ResourceData, meta interface{}) error {
|
2015-10-27 11:04:19 +01:00
|
|
|
client := meta.(*Client)
|
|
|
|
conn, err := client.Connect()
|
|
|
|
if err != nil {
|
2016-09-05 23:46:40 +02:00
|
|
|
return errwrap.Wrapf("Error connecting to PostgreSQL: {{err}}", err)
|
2015-10-27 11:04:19 +01:00
|
|
|
}
|
|
|
|
defer conn.Close()
|
|
|
|
|
|
|
|
dbName := d.Get("name").(string)
|
|
|
|
connUsername := client.username
|
|
|
|
dbOwner := d.Get("owner").(string)
|
|
|
|
//needed in order to set the owner of the db if the connection user is not a superuser
|
|
|
|
err = grantRoleMembership(conn, dbOwner, connUsername)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
query := fmt.Sprintf("DROP DATABASE %s", pq.QuoteIdentifier(dbName))
|
|
|
|
_, err = conn.Query(query)
|
|
|
|
if err != nil {
|
2016-09-05 23:46:40 +02:00
|
|
|
return errwrap.Wrapf("Error dropping database: {{err}}", err)
|
2015-10-27 11:04:19 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
d.SetId("")
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-09-06 00:04:48 +02:00
|
|
|
func resourcePostgreSQLDatabaseRead(d *schema.ResourceData, meta interface{}) error {
|
2015-10-27 11:04:19 +01:00
|
|
|
client := meta.(*Client)
|
|
|
|
conn, err := client.Connect()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer conn.Close()
|
|
|
|
|
|
|
|
dbName := d.Get("name").(string)
|
|
|
|
|
|
|
|
var owner string
|
|
|
|
err = conn.QueryRow("SELECT pg_catalog.pg_get_userbyid(d.datdba) from pg_database d WHERE datname=$1", dbName).Scan(&owner)
|
|
|
|
switch {
|
|
|
|
case err == sql.ErrNoRows:
|
|
|
|
d.SetId("")
|
|
|
|
return nil
|
|
|
|
case err != nil:
|
2016-09-06 00:04:48 +02:00
|
|
|
return errwrap.Wrapf("Error reading database: {{err}}", err)
|
2015-10-27 11:04:19 +01:00
|
|
|
default:
|
|
|
|
d.Set("owner", owner)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-06 00:04:48 +02:00
|
|
|
func resourcePostgreSQLDatabaseUpdate(d *schema.ResourceData, meta interface{}) error {
|
2015-10-27 11:04:19 +01:00
|
|
|
client := meta.(*Client)
|
|
|
|
conn, err := client.Connect()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer conn.Close()
|
|
|
|
|
|
|
|
dbName := d.Get("name").(string)
|
|
|
|
|
|
|
|
if d.HasChange("owner") {
|
|
|
|
owner := d.Get("owner").(string)
|
|
|
|
if owner != "" {
|
|
|
|
query := fmt.Sprintf("ALTER DATABASE %s OWNER TO %s", pq.QuoteIdentifier(dbName), pq.QuoteIdentifier(owner))
|
|
|
|
_, err := conn.Query(query)
|
|
|
|
if err != nil {
|
2016-09-06 00:04:48 +02:00
|
|
|
return errwrap.Wrapf("Error updating owner: {{err}}", err)
|
2015-10-27 11:04:19 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-06 00:04:48 +02:00
|
|
|
return resourcePostgreSQLDatabaseRead(d, meta)
|
2015-10-27 11:04:19 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
func grantRoleMembership(conn *sql.DB, dbOwner string, connUsername string) error {
|
|
|
|
if dbOwner != "" && dbOwner != connUsername {
|
|
|
|
query := fmt.Sprintf("GRANT %s TO %s", pq.QuoteIdentifier(dbOwner), pq.QuoteIdentifier(connUsername))
|
|
|
|
_, err := conn.Query(query)
|
|
|
|
if err != nil {
|
|
|
|
//is already member or role
|
|
|
|
if strings.Contains(err.Error(), "duplicate key value violates unique constraint") {
|
|
|
|
return nil
|
|
|
|
}
|
2016-09-05 23:46:40 +02:00
|
|
|
return errwrap.Wrapf("Error granting membership: {{err}}", err)
|
2015-10-27 11:04:19 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|