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 }