github.com/candidpartners/terraform@v0.9.5-0.20171005231213-29f5f88820f6/builtin/providers/netapp/provider.go (about)

     1  package netapp
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  	"time"
     7  
     8  	"github.com/candidpartners/occm-sdk-go/api/workenv"
     9  	"github.com/hashicorp/terraform/helper/schema"
    10  	"github.com/hashicorp/terraform/terraform"
    11  )
    12  
    13  const REQUEST_RESOLUTION_RETRY_COUNT = 60
    14  const REQUEST_RESOLUTION_WAIT_TIME = 2 * time.Second
    15  
    16  // Provider represents a resource provider in Terraform
    17  func Provider() terraform.ResourceProvider {
    18  	return &schema.Provider{
    19  		Schema: map[string]*schema.Schema{
    20  			"email": {
    21  				Type:        schema.TypeString,
    22  				Required:    true,
    23  				DefaultFunc: schema.EnvDefaultFunc("NETAPP_EMAIL", nil),
    24  			},
    25  			"password": {
    26  				Type:        schema.TypeString,
    27  				Required:    true,
    28  				DefaultFunc: schema.EnvDefaultFunc("NETAPP_PASSWORD", nil),
    29  				Sensitive:   true,
    30  			},
    31  			"host": {
    32  				Type:        schema.TypeString,
    33  				Optional:    true,
    34  				DefaultFunc: schema.EnvDefaultFunc("NETAPP_HOST", nil),
    35  			},
    36  		},
    37  
    38  		DataSourcesMap: map[string]*schema.Resource{
    39  			"netapp_cloud_workenv": dataSourceCloudWorkingEnvironment(),
    40  		},
    41  
    42  		ResourcesMap: map[string]*schema.Resource{
    43  			"netapp_cloud_volume": resourceCloudVolume(),
    44  		},
    45  
    46  		ConfigureFunc: providerConfigure,
    47  	}
    48  }
    49  
    50  func providerConfigure(data *schema.ResourceData) (interface{}, error) {
    51  	config := Config{
    52  		Host:     data.Get("host").(string),
    53  		Email:    data.Get("email").(string),
    54  		Password: data.Get("password").(string),
    55  	}
    56  
    57  	apis, err := config.APIs()
    58  	if err != nil {
    59  		return nil, fmt.Errorf("Error creating APIs: %s", err)
    60  	}
    61  
    62  	log.Println("[INFO] Initializing NetApp client")
    63  
    64  	err = apis.AuthAPI.Login(config.Email, config.Password)
    65  	if err != nil {
    66  		return nil, fmt.Errorf("Error logging in user %s: %s", config.Email, err)
    67  	}
    68  
    69  	return apis, nil
    70  }
    71  
    72  func GetWorkingEnvironments(apis *APIs) ([]workenv.VsaWorkingEnvironment, error) {
    73  	resp, err := apis.WorkingEnvironmentAPI.GetWorkingEnvironments()
    74  	if err != nil {
    75  		return nil, err
    76  	}
    77  
    78  	return resp.VSA, nil
    79  }
    80  
    81  func GetWorkingEnvironmentByName(apis *APIs, workEnvName string) (*workenv.VsaWorkingEnvironment, error) {
    82  	workEnvs, err := GetWorkingEnvironments(apis)
    83  	if err != nil {
    84  		return nil, err
    85  	}
    86  
    87  	log.Printf("[DEBUG] Reading working environment %s", workEnvName)
    88  
    89  	var found *workenv.VsaWorkingEnvironment
    90  
    91  	for _, workenv := range workEnvs {
    92  		if workenv.Name == workEnvName {
    93  			found = &workenv
    94  			break
    95  		}
    96  	}
    97  
    98  	if found == nil {
    99  		return nil, fmt.Errorf("Working environment %s not found", workEnvName)
   100  	}
   101  
   102  	log.Printf("[DEBUG] Found working environment %s", workEnvName)
   103  
   104  	return found, nil
   105  }
   106  
   107  func GetWorkingEnvironmentById(apis *APIs, workEnvId string) (*workenv.VsaWorkingEnvironment, error) {
   108  	workEnvs, err := GetWorkingEnvironments(apis)
   109  	if err != nil {
   110  		return nil, err
   111  	}
   112  
   113  	log.Printf("[DEBUG] Reading working environment for ID %s", workEnvId)
   114  
   115  	var found *workenv.VsaWorkingEnvironment
   116  
   117  	for _, workEnv := range workEnvs {
   118  		if workEnv.PublicId == workEnvId {
   119  			found = &workEnv
   120  			break
   121  		}
   122  	}
   123  
   124  	if found == nil {
   125  		return nil, fmt.Errorf("Working environment with ID %s not found", workEnvId)
   126  	}
   127  
   128  	return found, nil
   129  }
   130  
   131  func WaitForRequest(apis *APIs, requestId string) error {
   132  	log.Printf("[DEBUG] Waiting for completion of request %s", requestId)
   133  
   134  	for i := 0; i < REQUEST_RESOLUTION_RETRY_COUNT; i++ {
   135  		summary, err := apis.AuditAPI.GetAuditSummary(requestId)
   136  		if err != nil {
   137  			return err
   138  		}
   139  
   140  		log.Printf("[DEBUG] Received status for request %s: %s", requestId, summary.Status)
   141  
   142  		if summary.Status == "Failed" {
   143  			log.Printf("[DEBUG] Failure detected, breaking wait loop")
   144  			return fmt.Errorf(summary.ErrorMessage)
   145  		}
   146  
   147  		if summary.Status == "Success" {
   148  			log.Printf("[DEBUG] Request completion detected, breaking wait loop")
   149  			return nil
   150  		}
   151  
   152  		time.Sleep(REQUEST_RESOLUTION_WAIT_TIME)
   153  	}
   154  
   155  	return fmt.Errorf("Timed out waiting for request completion")
   156  }