github.com/skyscape-cloud-services/terraform@v0.9.2-0.20170609144644-7ece028a1747/builtin/providers/rancher/resource_rancher_registration_token.go (about)

     1  package rancher
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  	"time"
     7  
     8  	"github.com/hashicorp/terraform/helper/resource"
     9  	"github.com/hashicorp/terraform/helper/schema"
    10  	rancherClient "github.com/rancher/go-rancher/v2"
    11  )
    12  
    13  func resourceRancherRegistrationToken() *schema.Resource {
    14  	return &schema.Resource{
    15  		Create: resourceRancherRegistrationTokenCreate,
    16  		Read:   resourceRancherRegistrationTokenRead,
    17  		Delete: resourceRancherRegistrationTokenDelete,
    18  		Update: resourceRancherRegistrationTokenUpdate,
    19  		Importer: &schema.ResourceImporter{
    20  			State: resourceRancherRegistrationTokenImport,
    21  		},
    22  
    23  		Schema: map[string]*schema.Schema{
    24  			"id": &schema.Schema{
    25  				Type:     schema.TypeString,
    26  				Computed: true,
    27  			},
    28  			"name": &schema.Schema{
    29  				Type:     schema.TypeString,
    30  				Required: true,
    31  				ForceNew: true,
    32  			},
    33  			"description": &schema.Schema{
    34  				Type:     schema.TypeString,
    35  				Optional: true,
    36  				ForceNew: true,
    37  			},
    38  			"environment_id": &schema.Schema{
    39  				Type:     schema.TypeString,
    40  				Required: true,
    41  				ForceNew: true,
    42  			},
    43  			"token": &schema.Schema{
    44  				Type:     schema.TypeString,
    45  				Computed: true,
    46  			},
    47  			"registration_url": &schema.Schema{
    48  				Type:     schema.TypeString,
    49  				Computed: true,
    50  			},
    51  			"command": &schema.Schema{
    52  				Type:     schema.TypeString,
    53  				Computed: true,
    54  			},
    55  			"image": &schema.Schema{
    56  				Type:     schema.TypeString,
    57  				Computed: true,
    58  			},
    59  			"host_labels": {
    60  				Type:     schema.TypeMap,
    61  				Optional: true,
    62  			},
    63  		},
    64  	}
    65  }
    66  
    67  func resourceRancherRegistrationTokenCreate(d *schema.ResourceData, meta interface{}) error {
    68  	log.Printf("[INFO] Creating RegistrationToken: %s", d.Id())
    69  	client, err := meta.(*Config).EnvironmentClient(d.Get("environment_id").(string))
    70  	if err != nil {
    71  		return err
    72  	}
    73  
    74  	name := d.Get("name").(string)
    75  	description := d.Get("description").(string)
    76  
    77  	data := map[string]interface{}{
    78  		"name":        &name,
    79  		"description": &description,
    80  	}
    81  
    82  	var newRegT rancherClient.RegistrationToken
    83  	if err := client.Create("registrationToken", data, &newRegT); err != nil {
    84  		return err
    85  	}
    86  
    87  	stateConf := &resource.StateChangeConf{
    88  		Pending:    []string{"active", "removed", "removing"},
    89  		Target:     []string{"active"},
    90  		Refresh:    RegistrationTokenStateRefreshFunc(client, newRegT.Id),
    91  		Timeout:    10 * time.Minute,
    92  		Delay:      1 * time.Second,
    93  		MinTimeout: 3 * time.Second,
    94  	}
    95  	_, waitErr := stateConf.WaitForState()
    96  	if waitErr != nil {
    97  		return fmt.Errorf(
    98  			"Error waiting for registration token (%s) to be created: %s", newRegT.Id, waitErr)
    99  	}
   100  
   101  	d.SetId(newRegT.Id)
   102  	log.Printf("[INFO] RegistrationToken ID: %s", d.Id())
   103  
   104  	return resourceRancherRegistrationTokenRead(d, meta)
   105  }
   106  
   107  func resourceRancherRegistrationTokenRead(d *schema.ResourceData, meta interface{}) error {
   108  	log.Printf("[INFO] Refreshing RegistrationToken: %s", d.Id())
   109  	client, err := meta.(*Config).EnvironmentClient(d.Get("environment_id").(string))
   110  	if err != nil {
   111  		return err
   112  	}
   113  
   114  	regT, err := client.RegistrationToken.ById(d.Id())
   115  	if err != nil {
   116  		return err
   117  	}
   118  
   119  	if regT == nil {
   120  		log.Printf("[INFO] RegistrationToken %s not found", d.Id())
   121  		d.SetId("")
   122  		return nil
   123  	}
   124  
   125  	if removed(regT.State) {
   126  		log.Printf("[INFO] Registration Token %s was removed on %v", d.Id(), regT.Removed)
   127  		d.SetId("")
   128  		return nil
   129  	}
   130  
   131  	regCommand := addHostLabels(regT.Command, d.Get("host_labels").(map[string]interface{}))
   132  	log.Printf("[INFO] RegistrationToken Name: %s", regT.Name)
   133  
   134  	d.Set("description", regT.Description)
   135  	d.Set("name", regT.Name)
   136  	d.Set("token", regT.Token)
   137  	d.Set("registration_url", regT.RegistrationUrl)
   138  	d.Set("environment_id", regT.AccountId)
   139  	d.Set("command", regCommand)
   140  	d.Set("image", regT.Image)
   141  
   142  	return nil
   143  }
   144  
   145  func resourceRancherRegistrationTokenDelete(d *schema.ResourceData, meta interface{}) error {
   146  	log.Printf("[INFO] Deleting RegistrationToken: %s", d.Id())
   147  	id := d.Id()
   148  	client, err := meta.(*Config).EnvironmentClient(d.Get("environment_id").(string))
   149  	if err != nil {
   150  		return err
   151  	}
   152  
   153  	regT, err := client.RegistrationToken.ById(id)
   154  	if err != nil {
   155  		return err
   156  	}
   157  
   158  	// Step 1: Deactivate
   159  	if _, e := client.RegistrationToken.ActionDeactivate(regT); e != nil {
   160  		return fmt.Errorf("Error deactivating RegistrationToken: %s", err)
   161  	}
   162  
   163  	log.Printf("[DEBUG] Waiting for registration token (%s) to be deactivated", id)
   164  
   165  	stateConf := &resource.StateChangeConf{
   166  		Pending:    []string{"active", "inactive", "deactivating"},
   167  		Target:     []string{"inactive"},
   168  		Refresh:    RegistrationTokenStateRefreshFunc(client, id),
   169  		Timeout:    10 * time.Minute,
   170  		Delay:      1 * time.Second,
   171  		MinTimeout: 3 * time.Second,
   172  	}
   173  
   174  	_, waitErr := stateConf.WaitForState()
   175  	if waitErr != nil {
   176  		return fmt.Errorf(
   177  			"Error waiting for registration token (%s) to be deactivated: %s", id, waitErr)
   178  	}
   179  
   180  	// Update resource to reflect its state
   181  	regT, err = client.RegistrationToken.ById(id)
   182  	if err != nil {
   183  		return fmt.Errorf("Failed to refresh state of deactivated registration token (%s): %s", id, err)
   184  	}
   185  
   186  	// Step 2: Remove
   187  	if _, err := client.RegistrationToken.ActionRemove(regT); err != nil {
   188  		return fmt.Errorf("Error removing RegistrationToken: %s", err)
   189  	}
   190  
   191  	log.Printf("[DEBUG] Waiting for registration token (%s) to be removed", id)
   192  
   193  	stateConf = &resource.StateChangeConf{
   194  		Pending:    []string{"inactive", "removed", "removing"},
   195  		Target:     []string{"removed"},
   196  		Refresh:    RegistrationTokenStateRefreshFunc(client, id),
   197  		Timeout:    10 * time.Minute,
   198  		Delay:      1 * time.Second,
   199  		MinTimeout: 3 * time.Second,
   200  	}
   201  
   202  	_, waitErr = stateConf.WaitForState()
   203  	if waitErr != nil {
   204  		return fmt.Errorf(
   205  			"Error waiting for registration token (%s) to be removed: %s", id, waitErr)
   206  	}
   207  
   208  	d.SetId("")
   209  	return nil
   210  }
   211  
   212  func resourceRancherRegistrationTokenUpdate(d *schema.ResourceData, meta interface{}) error {
   213  	//if d.HasChange("host_labels") {
   214  	//newCommand := addHostLabels(
   215  	//d.Get("command").(string),
   216  	//d.Get("host_labels").(map[string]interface{}))
   217  	//d.Set("command", newCommand)
   218  	//}
   219  	return resourceRancherRegistrationTokenRead(d, meta)
   220  }
   221  
   222  func resourceRancherRegistrationTokenImport(d *schema.ResourceData, meta interface{}) ([]*schema.ResourceData, error) {
   223  	envID, resourceID := splitID(d.Id())
   224  	d.SetId(resourceID)
   225  	if envID != "" {
   226  		d.Set("environment_id", envID)
   227  	} else {
   228  		client, err := meta.(*Config).GlobalClient()
   229  		if err != nil {
   230  			return []*schema.ResourceData{}, err
   231  		}
   232  		token, err := client.RegistrationToken.ById(d.Id())
   233  		if err != nil {
   234  			return []*schema.ResourceData{}, err
   235  		}
   236  		d.Set("environment_id", token.AccountId)
   237  	}
   238  	return []*schema.ResourceData{d}, nil
   239  }
   240  
   241  // RegistrationTokenStateRefreshFunc returns a resource.StateRefreshFunc that is used to watch
   242  // a Rancher RegistrationToken.
   243  func RegistrationTokenStateRefreshFunc(client *rancherClient.RancherClient, regTID string) resource.StateRefreshFunc {
   244  	return func() (interface{}, string, error) {
   245  		regT, err := client.RegistrationToken.ById(regTID)
   246  
   247  		if err != nil {
   248  			return nil, "", err
   249  		}
   250  
   251  		return regT, regT.State, nil
   252  	}
   253  }