github.com/mkuzmin/terraform@v0.3.7-0.20161118171027-ec4c00ff92a9/builtin/providers/google/provider.go (about) 1 package google 2 3 import ( 4 "encoding/json" 5 "fmt" 6 "strings" 7 8 "github.com/hashicorp/terraform/helper/pathorcontents" 9 "github.com/hashicorp/terraform/helper/schema" 10 "github.com/hashicorp/terraform/terraform" 11 "google.golang.org/api/compute/v1" 12 "google.golang.org/api/googleapi" 13 ) 14 15 // Provider returns a terraform.ResourceProvider. 16 func Provider() terraform.ResourceProvider { 17 return &schema.Provider{ 18 Schema: map[string]*schema.Schema{ 19 "account_file": &schema.Schema{ 20 Type: schema.TypeString, 21 Optional: true, 22 DefaultFunc: schema.EnvDefaultFunc("GOOGLE_ACCOUNT_FILE", nil), 23 ValidateFunc: validateAccountFile, 24 Deprecated: "Use the credentials field instead", 25 }, 26 27 "credentials": &schema.Schema{ 28 Type: schema.TypeString, 29 Optional: true, 30 DefaultFunc: schema.MultiEnvDefaultFunc([]string{ 31 "GOOGLE_CREDENTIALS", 32 "GOOGLE_CLOUD_KEYFILE_JSON", 33 "GCLOUD_KEYFILE_JSON", 34 }, nil), 35 ValidateFunc: validateCredentials, 36 }, 37 38 "project": &schema.Schema{ 39 Type: schema.TypeString, 40 Optional: true, 41 DefaultFunc: schema.MultiEnvDefaultFunc([]string{ 42 "GOOGLE_PROJECT", 43 "GCLOUD_PROJECT", 44 "CLOUDSDK_CORE_PROJECT", 45 }, nil), 46 }, 47 48 "region": &schema.Schema{ 49 Type: schema.TypeString, 50 Required: true, 51 DefaultFunc: schema.MultiEnvDefaultFunc([]string{ 52 "GOOGLE_REGION", 53 "GCLOUD_REGION", 54 "CLOUDSDK_COMPUTE_REGION", 55 }, nil), 56 }, 57 }, 58 59 DataSourcesMap: map[string]*schema.Resource{ 60 "google_iam_policy": dataSourceGoogleIamPolicy(), 61 }, 62 63 ResourcesMap: map[string]*schema.Resource{ 64 "google_compute_autoscaler": resourceComputeAutoscaler(), 65 "google_compute_address": resourceComputeAddress(), 66 "google_compute_backend_service": resourceComputeBackendService(), 67 "google_compute_disk": resourceComputeDisk(), 68 "google_compute_firewall": resourceComputeFirewall(), 69 "google_compute_forwarding_rule": resourceComputeForwardingRule(), 70 "google_compute_global_address": resourceComputeGlobalAddress(), 71 "google_compute_global_forwarding_rule": resourceComputeGlobalForwardingRule(), 72 "google_compute_http_health_check": resourceComputeHttpHealthCheck(), 73 "google_compute_https_health_check": resourceComputeHttpsHealthCheck(), 74 "google_compute_image": resourceComputeImage(), 75 "google_compute_instance": resourceComputeInstance(), 76 "google_compute_instance_group": resourceComputeInstanceGroup(), 77 "google_compute_instance_group_manager": resourceComputeInstanceGroupManager(), 78 "google_compute_instance_template": resourceComputeInstanceTemplate(), 79 "google_compute_network": resourceComputeNetwork(), 80 "google_compute_project_metadata": resourceComputeProjectMetadata(), 81 "google_compute_route": resourceComputeRoute(), 82 "google_compute_ssl_certificate": resourceComputeSslCertificate(), 83 "google_compute_subnetwork": resourceComputeSubnetwork(), 84 "google_compute_target_http_proxy": resourceComputeTargetHttpProxy(), 85 "google_compute_target_https_proxy": resourceComputeTargetHttpsProxy(), 86 "google_compute_target_pool": resourceComputeTargetPool(), 87 "google_compute_url_map": resourceComputeUrlMap(), 88 "google_compute_vpn_gateway": resourceComputeVpnGateway(), 89 "google_compute_vpn_tunnel": resourceComputeVpnTunnel(), 90 "google_container_cluster": resourceContainerCluster(), 91 "google_dns_managed_zone": resourceDnsManagedZone(), 92 "google_dns_record_set": resourceDnsRecordSet(), 93 "google_sql_database": resourceSqlDatabase(), 94 "google_sql_database_instance": resourceSqlDatabaseInstance(), 95 "google_sql_user": resourceSqlUser(), 96 "google_project": resourceGoogleProject(), 97 "google_pubsub_topic": resourcePubsubTopic(), 98 "google_pubsub_subscription": resourcePubsubSubscription(), 99 "google_service_account": resourceGoogleServiceAccount(), 100 "google_storage_bucket": resourceStorageBucket(), 101 "google_storage_bucket_acl": resourceStorageBucketAcl(), 102 "google_storage_bucket_object": resourceStorageBucketObject(), 103 "google_storage_object_acl": resourceStorageObjectAcl(), 104 }, 105 106 ConfigureFunc: providerConfigure, 107 } 108 } 109 110 func providerConfigure(d *schema.ResourceData) (interface{}, error) { 111 credentials := d.Get("credentials").(string) 112 if credentials == "" { 113 credentials = d.Get("account_file").(string) 114 } 115 config := Config{ 116 Credentials: credentials, 117 Project: d.Get("project").(string), 118 Region: d.Get("region").(string), 119 } 120 121 if err := config.loadAndValidate(); err != nil { 122 return nil, err 123 } 124 125 return &config, nil 126 } 127 128 func validateAccountFile(v interface{}, k string) (warnings []string, errors []error) { 129 if v == nil { 130 return 131 } 132 133 value := v.(string) 134 135 if value == "" { 136 return 137 } 138 139 contents, wasPath, err := pathorcontents.Read(value) 140 if err != nil { 141 errors = append(errors, fmt.Errorf("Error loading Account File: %s", err)) 142 } 143 if wasPath { 144 warnings = append(warnings, `account_file was provided as a path instead of 145 as file contents. This support will be removed in the future. Please update 146 your configuration to use ${file("filename.json")} instead.`) 147 } 148 149 var account accountFile 150 if err := json.Unmarshal([]byte(contents), &account); err != nil { 151 errors = append(errors, 152 fmt.Errorf("account_file not valid JSON '%s': %s", contents, err)) 153 } 154 155 return 156 } 157 158 func validateCredentials(v interface{}, k string) (warnings []string, errors []error) { 159 if v == nil || v.(string) == "" { 160 return 161 } 162 creds := v.(string) 163 var account accountFile 164 if err := json.Unmarshal([]byte(creds), &account); err != nil { 165 errors = append(errors, 166 fmt.Errorf("credentials are not valid JSON '%s': %s", creds, err)) 167 } 168 169 return 170 } 171 172 // getRegionFromZone returns the region from a zone for Google cloud. 173 func getRegionFromZone(zone string) string { 174 if zone != "" && len(zone) > 2 { 175 region := zone[:len(zone)-2] 176 return region 177 } 178 return "" 179 } 180 181 // getRegion reads the "region" field from the given resource data and falls 182 // back to the provider's value if not given. If the provider's value is not 183 // given, an error is returned. 184 func getRegion(d *schema.ResourceData, config *Config) (string, error) { 185 res, ok := d.GetOk("region") 186 if !ok { 187 if config.Region != "" { 188 return config.Region, nil 189 } 190 return "", fmt.Errorf("%q: required field is not set", "region") 191 } 192 return res.(string), nil 193 } 194 195 // getProject reads the "project" field from the given resource data and falls 196 // back to the provider's value if not given. If the provider's value is not 197 // given, an error is returned. 198 func getProject(d *schema.ResourceData, config *Config) (string, error) { 199 res, ok := d.GetOk("project") 200 if !ok { 201 if config.Project != "" { 202 return config.Project, nil 203 } 204 return "", fmt.Errorf("%q: required field is not set", "project") 205 } 206 return res.(string), nil 207 } 208 209 func getZonalResourceFromRegion(getResource func(string) (interface{}, error), region string, compute *compute.Service, project string) (interface{}, error) { 210 zoneList, err := compute.Zones.List(project).Do() 211 if err != nil { 212 return nil, err 213 } 214 var resource interface{} 215 for _, zone := range zoneList.Items { 216 if strings.Contains(zone.Name, region) { 217 resource, err = getResource(zone.Name) 218 if err != nil { 219 if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 { 220 // Resource was not found in this zone 221 continue 222 } 223 return nil, fmt.Errorf("Error reading Resource: %s", err) 224 } 225 // Resource was found 226 return resource, nil 227 } 228 } 229 // Resource does not exist in this region 230 return nil, nil 231 } 232 233 // getNetworkLink reads the "network" field from the given resource data and if the value: 234 // - is a resource URL, returns the string unchanged 235 // - is the network name only, then looks up the resource URL using the google client 236 func getNetworkLink(d *schema.ResourceData, config *Config, field string) (string, error) { 237 if v, ok := d.GetOk(field); ok { 238 network := v.(string) 239 240 project, err := getProject(d, config) 241 if err != nil { 242 return "", err 243 } 244 245 if !strings.HasPrefix(network, "https://www.googleapis.com/compute/") { 246 // Network value provided is just the name, lookup the network SelfLink 247 networkData, err := config.clientCompute.Networks.Get( 248 project, network).Do() 249 if err != nil { 250 return "", fmt.Errorf("Error reading network: %s", err) 251 } 252 network = networkData.SelfLink 253 } 254 255 return network, nil 256 257 } else { 258 return "", nil 259 } 260 } 261 262 // getNetworkName reads the "network" field from the given resource data and if the value: 263 // - is a resource URL, extracts the network name from the URL and returns it 264 // - is the network name only (i.e not prefixed with http://www.googleapis.com/compute/...), is returned unchanged 265 func getNetworkName(d *schema.ResourceData, field string) (string, error) { 266 if v, ok := d.GetOk(field); ok { 267 network := v.(string) 268 269 if strings.HasPrefix(network, "https://www.googleapis.com/compute/") { 270 // extract the network name from SelfLink URL 271 networkName := network[strings.LastIndex(network, "/")+1:] 272 if networkName == "" { 273 return "", fmt.Errorf("network url not valid") 274 } 275 return networkName, nil 276 } 277 278 return network, nil 279 } 280 return "", nil 281 }