terraform/builtin/providers/rancher/resource_rancher_stack.go

385 lines
9.9 KiB
Go
Raw Normal View History

package rancher
import (
"fmt"
"log"
"strings"
"time"
"github.com/hashicorp/terraform/helper/resource"
"github.com/hashicorp/terraform/helper/schema"
"github.com/hashicorp/terraform/helper/validation"
rancherClient "github.com/rancher/go-rancher/client"
)
func resourceRancherStack() *schema.Resource {
return &schema.Resource{
Create: resourceRancherStackCreate,
Read: resourceRancherStackRead,
Update: resourceRancherStackUpdate,
Delete: resourceRancherStackDelete,
Importer: &schema.ResourceImporter{
State: schema.ImportStatePassthrough,
},
Schema: map[string]*schema.Schema{
"id": &schema.Schema{
Type: schema.TypeString,
Computed: true,
},
"name": &schema.Schema{
Type: schema.TypeString,
Required: true,
},
"description": &schema.Schema{
Type: schema.TypeString,
Optional: true,
},
"environment_id": {
Type: schema.TypeString,
Required: true,
ForceNew: true,
},
"docker_compose": {
Type: schema.TypeString,
Optional: true,
},
"rancher_compose": {
Type: schema.TypeString,
Optional: true,
},
"environment": {
Type: schema.TypeMap,
Optional: true,
},
"catalog_id": {
Type: schema.TypeString,
Optional: true,
},
"scope": {
Type: schema.TypeString,
Default: "user",
Optional: true,
ValidateFunc: validation.StringInSlice([]string{"user", "system"}, true),
},
"start_on_create": {
Type: schema.TypeBool,
Optional: true,
Computed: true,
},
"finish_upgrade": {
Type: schema.TypeBool,
Optional: true,
},
"rendered_docker_compose": {
Type: schema.TypeString,
Computed: true,
},
"rendered_rancher_compose": {
Type: schema.TypeString,
Computed: true,
},
},
}
}
func resourceRancherStackCreate(d *schema.ResourceData, meta interface{}) error {
log.Printf("[INFO] Creating Stack: %s", d.Id())
client, err := meta.(*Config).EnvironmentClient(d.Get("environment_id").(string))
if err != nil {
return err
}
data, err := makeStackData(d, meta)
if err != nil {
return err
}
var newStack rancherClient.Environment
if err := client.Create("environment", data, &newStack); err != nil {
return err
}
stateConf := &resource.StateChangeConf{
Pending: []string{"activating", "active", "removed", "removing"},
Target: []string{"active"},
Refresh: StackStateRefreshFunc(client, newStack.Id),
Timeout: 10 * time.Minute,
Delay: 1 * time.Second,
MinTimeout: 3 * time.Second,
}
_, waitErr := stateConf.WaitForState()
if waitErr != nil {
return fmt.Errorf(
"Error waiting for stack (%s) to be created: %s", newStack.Id, waitErr)
}
d.SetId(newStack.Id)
log.Printf("[INFO] Stack ID: %s", d.Id())
return resourceRancherStackRead(d, meta)
}
func resourceRancherStackRead(d *schema.ResourceData, meta interface{}) error {
log.Printf("[INFO] Refreshing Stack: %s", d.Id())
client := meta.(*Config)
stack, err := client.Environment.ById(d.Id())
if err != nil {
return err
}
config, err := client.Environment.ActionExportconfig(stack, &rancherClient.ComposeConfigInput{})
if err != nil {
return err
}
log.Printf("[INFO] Stack Name: %s", stack.Name)
d.Set("description", stack.Description)
d.Set("name", stack.Name)
d.Set("rendered_docker_compose", strings.Replace(config.DockerComposeConfig, "\r", "", -1))
d.Set("rendered_rancher_compose", strings.Replace(config.RancherComposeConfig, "\r", "", -1))
d.Set("environment_id", stack.AccountId)
d.Set("environment", stack.Environment)
if stack.ExternalId == "" {
d.Set("scope", "user")
d.Set("catalog_id", "")
} else {
trimmedID := strings.TrimPrefix(stack.ExternalId, "system-")
if trimmedID == stack.ExternalId {
d.Set("scope", "user")
} else {
d.Set("scope", "system")
}
d.Set("catalog_id", strings.TrimPrefix(trimmedID, "catalog://"))
}
d.Set("start_on_create", stack.StartOnCreate)
return nil
}
func resourceRancherStackUpdate(d *schema.ResourceData, meta interface{}) error {
log.Printf("[INFO] Updating Stack: %s", d.Id())
client, err := meta.(*Config).EnvironmentClient(d.Get("environment_id").(string))
if err != nil {
return err
}
d.Partial(true)
data, err := makeStackData(d, meta)
if err != nil {
return err
}
stack, err := client.Environment.ById(d.Id())
if err != nil {
return err
}
var newStack rancherClient.Environment
if err := client.Update("environment", &stack.Resource, data, &newStack); err != nil {
return err
}
stateConf := &resource.StateChangeConf{
Pending: []string{"active", "active-updating"},
Target: []string{"active"},
Refresh: StackStateRefreshFunc(client, newStack.Id),
Timeout: 10 * time.Minute,
Delay: 1 * time.Second,
MinTimeout: 3 * time.Second,
}
s, waitErr := stateConf.WaitForState()
stack = s.(*rancherClient.Environment)
if waitErr != nil {
return fmt.Errorf(
"Error waiting for stack (%s) to be updated: %s", stack.Id, waitErr)
}
d.SetPartial("name")
d.SetPartial("description")
d.SetPartial("scope")
if d.HasChange("docker_compose") ||
d.HasChange("rancher_compose") ||
d.HasChange("environment") ||
d.HasChange("catalog_id") {
envMap := make(map[string]interface{})
for key, value := range *data["environment"].(*map[string]string) {
envValue := value
envMap[key] = &envValue
}
stack, err = client.Environment.ActionUpgrade(stack, &rancherClient.EnvironmentUpgrade{
DockerCompose: *data["dockerCompose"].(*string),
RancherCompose: *data["rancherCompose"].(*string),
Environment: envMap,
ExternalId: *data["externalId"].(*string),
})
if err != nil {
return err
}
stateConf := &resource.StateChangeConf{
Pending: []string{"active", "upgrading", "upgraded"},
Target: []string{"upgraded"},
Refresh: StackStateRefreshFunc(client, stack.Id),
Timeout: 10 * time.Minute,
Delay: 1 * time.Second,
MinTimeout: 3 * time.Second,
}
s, waitErr := stateConf.WaitForState()
if waitErr != nil {
return fmt.Errorf(
"Error waiting for stack (%s) to be upgraded: %s", stack.Id, waitErr)
}
stack = s.(*rancherClient.Environment)
if d.Get("finish_upgrade").(bool) {
stack, err = client.Environment.ActionFinishupgrade(stack)
if err != nil {
return err
}
stateConf = &resource.StateChangeConf{
Pending: []string{"active", "upgraded"},
Target: []string{"active"},
Refresh: StackStateRefreshFunc(client, stack.Id),
Timeout: 10 * time.Minute,
Delay: 1 * time.Second,
MinTimeout: 3 * time.Second,
}
_, waitErr = stateConf.WaitForState()
if waitErr != nil {
return fmt.Errorf(
"Error waiting for stack (%s) to be upgraded: %s", stack.Id, waitErr)
}
}
d.SetPartial("rendered_docker_compose")
d.SetPartial("rendered_rancher_compose")
d.SetPartial("docker_compose")
d.SetPartial("rancher_compose")
d.SetPartial("environment")
d.SetPartial("catalog_id")
}
d.Partial(false)
return resourceRancherStackRead(d, meta)
}
func resourceRancherStackDelete(d *schema.ResourceData, meta interface{}) error {
log.Printf("[INFO] Deleting Stack: %s", d.Id())
id := d.Id()
client, err := meta.(*Config).EnvironmentClient(d.Get("environment_id").(string))
if err != nil {
return err
}
stack, err := client.Environment.ById(id)
if err != nil {
return err
}
if err := client.Environment.Delete(stack); err != nil {
return fmt.Errorf("Error deleting Stack: %s", err)
}
log.Printf("[DEBUG] Waiting for stack (%s) to be removed", id)
stateConf := &resource.StateChangeConf{
Pending: []string{"active", "removed", "removing"},
Target: []string{"removed"},
Refresh: StackStateRefreshFunc(client, id),
Timeout: 10 * time.Minute,
Delay: 1 * time.Second,
MinTimeout: 3 * time.Second,
}
_, waitErr := stateConf.WaitForState()
if waitErr != nil {
return fmt.Errorf(
"Error waiting for stack (%s) to be removed: %s", id, waitErr)
}
d.SetId("")
return nil
}
// StackStateRefreshFunc returns a resource.StateRefreshFunc that is used to watch
// a Rancher Stack.
func StackStateRefreshFunc(client *rancherClient.RancherClient, stackID string) resource.StateRefreshFunc {
return func() (interface{}, string, error) {
stack, err := client.Environment.ById(stackID)
if err != nil {
return nil, "", err
}
return stack, stack.State, nil
}
}
func environmentFromMap(m map[string]interface{}) map[string]string {
result := make(map[string]string)
for k, v := range m {
result[k] = v.(string)
}
return result
}
func makeStackData(d *schema.ResourceData, meta interface{}) (data map[string]interface{}, err error) {
name := d.Get("name").(string)
description := d.Get("description").(string)
var externalID string
var dockerCompose string
var rancherCompose string
var environment map[string]string
if c, ok := d.GetOk("catalog_id"); ok {
if scope, ok := d.GetOk("scope"); ok && scope.(string) == "system" {
externalID = "system-"
}
catalogID := c.(string)
externalID += "catalog://" + catalogID
catalogClient, err := meta.(*Config).CatalogClient()
if err != nil {
return data, err
}
template, err := catalogClient.Template.ById(catalogID)
if err != nil {
return data, fmt.Errorf("Failed to get catalog template: %s", err)
}
dockerCompose = template.Files["docker-compose.yml"].(string)
rancherCompose = template.Files["rancher-compose.yml"].(string)
}
if c, ok := d.GetOk("docker_compose"); ok {
dockerCompose = c.(string)
}
if c, ok := d.GetOk("rancher_compose"); ok {
rancherCompose = c.(string)
}
environment = environmentFromMap(d.Get("environment").(map[string]interface{}))
startOnCreate := d.Get("start_on_create")
data = map[string]interface{}{
"name": &name,
"description": &description,
"dockerCompose": &dockerCompose,
"rancherCompose": &rancherCompose,
"environment": &environment,
"externalId": &externalID,
"startOnCreate": &startOnCreate,
}
return data, nil
}