func resourceArmResourceGroupRead(d *schema.ResourceData, meta interface{}) error { resGroupClient := meta.(*ArmClient).resourceGroupClient id, err := parseAzureResourceID(d.Id()) if err != nil { return err } name := id.ResourceGroup res, err := resGroupClient.Get(name) if err != nil { if res.StatusCode == http.StatusNotFound { d.SetId("") return nil } return fmt.Errorf("Error issuing read request to Azure ARM for resource group '%s': %s", name, err) } d.Set("name", res.Name) d.Set("location", res.Location) flattenAndSetTags(d, res.Tags) return nil }
// resourceAzureLocalNetworkConnectionRead does all the necessary API calls to // read the state of our local natwork from Azure. func resourceAzureLocalNetworkConnectionRead(d *schema.ResourceData, meta interface{}) error { azureClient := meta.(*Client) vnetClient := azureClient.vnetClient log.Println("[INFO] Fetching current network configuration from Azure.") netConf, err := vnetClient.GetVirtualNetworkConfiguration() if err != nil { return fmt.Errorf("Failed to get the current network configuration from Azure: %s", err) } var found bool name := d.Get("name").(string) // browsing for our network config: for _, lnet := range netConf.Configuration.LocalNetworkSites { if lnet.Name == name { found = true d.Set("vpn_gateway_address", lnet.VPNGatewayAddress) d.Set("address_space_prefixes", lnet.AddressSpace.AddressPrefix) break } } // remove the resource from the state of it has been deleted in the meantime: if !found { log.Println(fmt.Printf("[INFO] Azure local network '%s' has been deleted remotely. Removimg from Terraform.", name)) d.SetId("") } return nil }
// resourceArmLocalNetworkGatewayRead goes ahead and reads the state of the corresponding ARM local network gateway. func resourceArmLocalNetworkGatewayRead(d *schema.ResourceData, meta interface{}) error { lnetClient := meta.(*ArmClient).localNetConnClient id, err := parseAzureResourceID(d.Id()) if err != nil { return err } name := id.Path["localNetworkGateways"] resGroup := id.ResourceGroup resp, err := lnetClient.Get(resGroup, name) if err != nil { if resp.StatusCode == http.StatusNotFound { d.SetId("") return nil } return fmt.Errorf("Error reading the state of Azure ARM local network gateway '%s': %s", name, err) } d.Set("gateway_address", resp.Properties.GatewayIPAddress) prefs := []string{} if ps := *resp.Properties.LocalNetworkAddressSpace.AddressPrefixes; ps != nil { prefs = ps } d.Set("address_space", prefs) return nil }
func resourceAwsProxyProtocolPolicyRead(d *schema.ResourceData, meta interface{}) error { elbconn := meta.(*AWSClient).elbconn elbname := aws.String(d.Get("load_balancer").(string)) // Retrieve the current ELB policies for updating the state req := &elb.DescribeLoadBalancersInput{ LoadBalancerNames: []*string{elbname}, } resp, err := elbconn.DescribeLoadBalancers(req) if err != nil { if isLoadBalancerNotFound(err) { // The ELB is gone now, so just remove it from the state d.SetId("") return nil } return fmt.Errorf("Error retrieving ELB attributes: %s", err) } backends := flattenBackendPolicies(resp.LoadBalancerDescriptions[0].BackendServerDescriptions) ports := []*string{} for ip := range backends { ipstr := strconv.Itoa(int(ip)) ports = append(ports, &ipstr) } d.Set("instance_ports", ports) d.Set("load_balancer", *elbname) return nil }
func resourceAwsIamUserPolicyRead(d *schema.ResourceData, meta interface{}) error { iamconn := meta.(*AWSClient).iamconn user, name := resourceAwsIamUserPolicyParseId(d.Id()) request := &iam.GetUserPolicyInput{ PolicyName: aws.String(name), UserName: aws.String(user), } var err error getResp, err := iamconn.GetUserPolicy(request) if err != nil { if iamerr, ok := err.(awserr.Error); ok && iamerr.Code() == "NoSuchEntity" { // XXX test me d.SetId("") return nil } return fmt.Errorf("Error reading IAM policy %s from user %s: %s", name, user, err) } if getResp.PolicyDocument == nil { return fmt.Errorf("GetUserPolicy returned a nil policy document") } policy, err := url.QueryUnescape(*getResp.PolicyDocument) if err != nil { return err } return d.Set("policy", policy) }
func resourceCloudStackNICRead(d *schema.ResourceData, meta interface{}) error { cs := meta.(*cloudstack.CloudStackClient) // Get the virtual machine details vm, count, err := cs.VirtualMachine.GetVirtualMachineByName(d.Get("virtual_machine").(string)) if err != nil { if count == 0 { log.Printf("[DEBUG] Instance %s does no longer exist", d.Get("virtual_machine").(string)) d.SetId("") return nil } else { return err } } // Read NIC info found := false for _, n := range vm.Nic { if n.Id == d.Id() { d.Set("ipaddress", n.Ipaddress) setValueOrID(d, "network", n.Networkname, n.Networkid) setValueOrID(d, "virtual_machine", vm.Name, vm.Id) found = true break } } if !found { log.Printf("[DEBUG] NIC for network %s does no longer exist", d.Get("network").(string)) d.SetId("") } return nil }
func resourceRemoteStateRead(d *schema.ResourceData, meta interface{}) error { backend := d.Get("backend").(string) config := make(map[string]string) for k, v := range d.Get("config").(map[string]interface{}) { config[k] = v.(string) } // Create the client to access our remote state log.Printf("[DEBUG] Initializing remote state client: %s", backend) client, err := remote.NewClient(backend, config) if err != nil { return err } // Create the remote state itself and refresh it in order to load the state log.Printf("[DEBUG] Loading remote state...") state := &remote.State{Client: client} if err := state.RefreshState(); err != nil { return err } var outputs map[string]string if !state.State().Empty() { outputs = state.State().RootModule().Outputs } d.SetId(time.Now().UTC().String()) d.Set("output", outputs) return nil }
func resourceCloudStackFirewallCreate(d *schema.ResourceData, meta interface{}) error { cs := meta.(*cloudstack.CloudStackClient) // Make sure all required parameters are there if err := verifyFirewallParams(d); err != nil { return err } // Retrieve the ipaddress ID ipaddressid, e := retrieveID(cs, "ipaddress", d.Get("ipaddress").(string)) if e != nil { return e.Error() } // We need to set this upfront in order to be able to save a partial state d.SetId(ipaddressid) // Create all rules that are configured if nrs := d.Get("rule").(*schema.Set); nrs.Len() > 0 { // Create an empty schema.Set to hold all rules rules := resourceCloudStackFirewall().Schema["rule"].ZeroValue().(*schema.Set) err := createFirewallRules(d, meta, rules, nrs) // We need to update this first to preserve the correct state d.Set("rule", rules) if err != nil { return err } } return resourceCloudStackFirewallRead(d, meta) }
func resourceAwsKeyPairRead(d *schema.ResourceData, meta interface{}) error { conn := meta.(*AWSClient).ec2conn req := &ec2.DescribeKeyPairsInput{ KeyNames: []*string{aws.String(d.Id())}, } resp, err := conn.DescribeKeyPairs(req) if err != nil { awsErr, ok := err.(awserr.Error) if ok && awsErr.Code() == "InvalidKeyPair.NotFound" { d.SetId("") return nil } return fmt.Errorf("Error retrieving KeyPair: %s", err) } for _, keyPair := range resp.KeyPairs { if *keyPair.KeyName == d.Id() { d.Set("key_name", keyPair.KeyName) d.Set("fingerprint", keyPair.KeyFingerprint) return nil } } return fmt.Errorf("Unable to find key pair within: %#v", resp.KeyPairs) }
// resourceAzureStorageBlobRead does all the necessary API calls to // read the status of the storage blob off Azure. func resourceAzureStorageBlobRead(d *schema.ResourceData, meta interface{}) error { azureClient := meta.(*Client) // check for it's existence: exists, err := resourceAzureStorageBlobExists(d, meta) if err != nil { return err } // if it exists; read relevant information: if exists { storName := d.Get("storage_service_name").(string) blobClient, err := azureClient.getStorageServiceBlobClient(storName) if err != nil { return err } name := d.Get("name").(string) cont := d.Get("storage_container_name").(string) url := blobClient.GetBlobURL(cont, name) d.Set("url", url) } // NOTE: no need to unset the ID here, as resourceAzureStorageBlobExists // already should have done so if it were required. return nil }
func resourceAwsSnsTopicRead(d *schema.ResourceData, meta interface{}) error { snsconn := meta.(*AWSClient).snsconn attributeOutput, err := snsconn.GetTopicAttributes(&sns.GetTopicAttributesInput{ TopicArn: aws.String(d.Id()), }) if err != nil { return err } if attributeOutput.Attributes != nil && len(attributeOutput.Attributes) > 0 { attrmap := attributeOutput.Attributes resource := *resourceAwsSnsTopic() // iKey = internal struct key, oKey = AWS Attribute Map key for iKey, oKey := range SNSAttributeMap { log.Printf("[DEBUG] Updating %s => %s", iKey, oKey) if attrmap[oKey] != nil { // Some of the fetched attributes are stateful properties such as // the number of subscriptions, the owner, etc. skip those if resource.Schema[iKey] != nil { value := *attrmap[oKey] log.Printf("[DEBUG] Updating %s => %s -> %s", iKey, oKey, value) d.Set(iKey, *attrmap[oKey]) } } } } return nil }
func resourceAwsSubnetRead(d *schema.ResourceData, meta interface{}) error { conn := meta.(*AWSClient).ec2conn resp, err := conn.DescribeSubnets(&ec2.DescribeSubnetsInput{ SubnetIds: []*string{aws.String(d.Id())}, }) if err != nil { if ec2err, ok := err.(awserr.Error); ok && ec2err.Code() == "InvalidSubnetID.NotFound" { // Update state to indicate the subnet no longer exists. d.SetId("") return nil } return err } if resp == nil { return nil } subnet := resp.Subnets[0] d.Set("vpc_id", subnet.VpcId) d.Set("availability_zone", subnet.AvailabilityZone) d.Set("cidr_block", subnet.CidrBlock) d.Set("map_public_ip_on_launch", subnet.MapPublicIpOnLaunch) d.Set("tags", tagsToMap(subnet.Tags)) return nil }
func resourceAwsSqsQueueRead(d *schema.ResourceData, meta interface{}) error { sqsconn := meta.(*AWSClient).sqsconn attributeOutput, err := sqsconn.GetQueueAttributes(&sqs.GetQueueAttributesInput{ QueueUrl: aws.String(d.Id()), AttributeNames: []*string{aws.String("All")}, }) if err != nil { return err } if attributeOutput.Attributes != nil && len(attributeOutput.Attributes) > 0 { attrmap := attributeOutput.Attributes resource := *resourceAwsSqsQueue() // iKey = internal struct key, oKey = AWS Attribute Map key for iKey, oKey := range AttributeMap { if attrmap[oKey] != nil { if resource.Schema[iKey].Type == schema.TypeInt { value, err := strconv.Atoi(*attrmap[oKey]) if err != nil { return err } d.Set(iKey, value) } else { d.Set(iKey, *attrmap[oKey]) } } } } return nil }
func resourceAwsAmiFromInstanceCreate(d *schema.ResourceData, meta interface{}) error { client := meta.(*AWSClient).ec2conn req := &ec2.CreateImageInput{ Name: aws.String(d.Get("name").(string)), Description: aws.String(d.Get("description").(string)), InstanceId: aws.String(d.Get("source_instance_id").(string)), NoReboot: aws.Bool(d.Get("snapshot_without_reboot").(bool)), } res, err := client.CreateImage(req) if err != nil { return err } id := *res.ImageId d.SetId(id) d.Partial(true) // make sure we record the id even if the rest of this gets interrupted d.Set("id", id) d.Set("manage_ebs_snapshots", true) d.SetPartial("id") d.SetPartial("manage_ebs_snapshots") d.Partial(false) _, err = resourceAwsAmiWaitForAvailable(id, client) if err != nil { return err } return resourceAwsAmiUpdate(d, meta) }
func resourceArmAvailabilitySetRead(d *schema.ResourceData, meta interface{}) error { availSetClient := meta.(*ArmClient).availSetClient id, err := parseAzureResourceID(d.Id()) if err != nil { return err } resGroup := id.ResourceGroup name := id.Path["availabilitySets"] resp, err := availSetClient.Get(resGroup, name) if resp.StatusCode == http.StatusNotFound { d.SetId("") return nil } if err != nil { return fmt.Errorf("Error making Read request on Azure Availability Set %s: %s", name, err) } availSet := *resp.Properties d.Set("platform_update_domain_count", availSet.PlatformUpdateDomainCount) d.Set("platform_fault_domain_count", availSet.PlatformFaultDomainCount) flattenAndSetTags(d, resp.Tags) return nil }
func instanceProfileSetRoles(d *schema.ResourceData, iamconn *iam.IAM) error { oldInterface, newInterface := d.GetChange("roles") oldRoles := oldInterface.(*schema.Set) newRoles := newInterface.(*schema.Set) currentRoles := schema.CopySet(oldRoles) d.Partial(true) for _, role := range oldRoles.Difference(newRoles).List() { err := instanceProfileRemoveRole(iamconn, d.Id(), role.(string)) if err != nil { return fmt.Errorf("Error removing role %s from IAM instance profile %s: %s", role, d.Id(), err) } currentRoles.Remove(role) d.Set("roles", currentRoles) d.SetPartial("roles") } for _, role := range newRoles.Difference(oldRoles).List() { err := instanceProfileAddRole(iamconn, d.Id(), role.(string)) if err != nil { return fmt.Errorf("Error adding role %s to IAM instance profile %s: %s", role, d.Id(), err) } currentRoles.Add(role) d.Set("roles", currentRoles) d.SetPartial("roles") } d.Partial(false) return nil }
func resourceAwsIamAccessKeyCreate(d *schema.ResourceData, meta interface{}) error { iamconn := meta.(*AWSClient).iamconn request := &iam.CreateAccessKeyInput{ UserName: aws.String(d.Get("user").(string)), } createResp, err := iamconn.CreateAccessKey(request) if err != nil { return fmt.Errorf( "Error creating access key for user %s: %s", *request.UserName, err, ) } if err := d.Set("secret", createResp.AccessKey.SecretAccessKey); err != nil { return err } d.Set("ses_smtp_password", sesSmtpPasswordFromSecretKey(createResp.AccessKey.SecretAccessKey)) return resourceAwsIamAccessKeyReadResult(d, &iam.AccessKeyMetadata{ AccessKeyId: createResp.AccessKey.AccessKeyId, CreateDate: createResp.AccessKey.CreateDate, Status: createResp.AccessKey.Status, UserName: createResp.AccessKey.UserName, }) }
func resourceArmNetworkSecurityGroupRead(d *schema.ResourceData, meta interface{}) error { secGroupClient := meta.(*ArmClient).secGroupClient id, err := parseAzureResourceID(d.Id()) if err != nil { return err } resGroup := id.ResourceGroup name := id.Path["networkSecurityGroups"] resp, err := secGroupClient.Get(resGroup, name, "") if resp.StatusCode == http.StatusNotFound { d.SetId("") return nil } if err != nil { return fmt.Errorf("Error making Read request on Azure Network Security Group %s: %s", name, err) } if resp.Properties.SecurityRules != nil { d.Set("security_rule", flattenNetworkSecurityRules(resp.Properties.SecurityRules)) } flattenAndSetTags(d, resp.Tags) return nil }
func resourceComputeProjectMetadataRead(d *schema.ResourceData, meta interface{}) error { config := meta.(*Config) // Load project service log.Printf("[DEBUG] Loading project service: %s", config.Project) project, err := config.clientCompute.Projects.Get(config.Project).Do() if err != nil { if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 { log.Printf("[WARN] Removing Project Metadata because it's gone") // The resource doesn't exist anymore d.SetId("") return nil } return fmt.Errorf("Error loading project '%s': %s", config.Project, err) } md := project.CommonInstanceMetadata if err = d.Set("metadata", MetadataFormatSchema(d.Get("metadata").(map[string]interface{}), md)); err != nil { return fmt.Errorf("Error setting metadata: %s", err) } d.SetId("common_metadata") return nil }
func resourceAwsRoute53DelegationSetCreate(d *schema.ResourceData, meta interface{}) error { r53 := meta.(*AWSClient).r53conn callerRef := resource.UniqueId() if v, ok := d.GetOk("reference_name"); ok { callerRef = strings.Join([]string{ v.(string), "-", callerRef, }, "") } input := &route53.CreateReusableDelegationSetInput{ CallerReference: aws.String(callerRef), } log.Printf("[DEBUG] Creating Route53 reusable delegation set: %#v", input) out, err := r53.CreateReusableDelegationSet(input) if err != nil { return err } log.Printf("[DEBUG] Route53 reusable delegation set created: %#v", out) set := out.DelegationSet d.SetId(cleanDelegationSetId(*set.Id)) d.Set("name_servers", expandNameServers(set.NameServers)) return nil }
func resourceAwsIamGroupMembershipRead(d *schema.ResourceData, meta interface{}) error { conn := meta.(*AWSClient).iamconn group := d.Get("group").(string) resp, err := conn.GetGroup(&iam.GetGroupInput{ GroupName: aws.String(group), }) if err != nil { if awsErr, ok := err.(awserr.Error); ok { // aws specific error if awsErr.Code() == "NoSuchEntity" { // group not found d.SetId("") return nil } } return err } ul := make([]string, 0, len(resp.Users)) for _, u := range resp.Users { ul = append(ul, *u.UserName) } if err := d.Set("users", ul); err != nil { return fmt.Errorf("[WARN] Error setting user list from IAM Group Membership (%s), error: %s", group, err) } return nil }
func resourceAwsOpsworksSetStackCustomCookbooksSource(d *schema.ResourceData, v *opsworks.Source) { nv := make([]interface{}, 0, 1) if v != nil { m := make(map[string]interface{}) if v.Type != nil { m["type"] = *v.Type } if v.Url != nil { m["url"] = *v.Url } if v.Username != nil { m["username"] = *v.Username } if v.Password != nil { m["password"] = *v.Password } if v.Revision != nil { m["revision"] = *v.Revision } nv = append(nv, m) } err := d.Set("custom_cookbooks_source", nv) if err != nil { // should never happen panic(err) } }
func resourceSqlDatabaseRead(d *schema.ResourceData, meta interface{}) error { config := meta.(*Config) database_name := d.Get("name").(string) instance_name := d.Get("instance").(string) project := config.Project db, err := config.clientSqlAdmin.Databases.Get(project, instance_name, database_name).Do() if err != nil { if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 { log.Printf("[WARN] Removing SQL Database %q because it's gone", d.Get("name").(string)) // The resource doesn't exist anymore d.SetId("") return nil } return fmt.Errorf("Error, failed to get"+ "database %s in instance %s: %s", database_name, instance_name, err) } d.Set("self_link", db.SelfLink) d.SetId(instance_name + ":" + database_name) return nil }
func resourceStorageBucketRead(d *schema.ResourceData, meta interface{}) error { config := meta.(*Config) // Get the bucket and acl bucket := d.Get("name").(string) res, err := config.clientStorage.Buckets.Get(bucket).Do() if err != nil { if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 { log.Printf("[WARN] Removing Bucket %q because it's gone", d.Get("name").(string)) // The resource doesn't exist anymore d.SetId("") return nil } return fmt.Errorf("Error reading bucket %s: %v", bucket, err) } log.Printf("[DEBUG] Read bucket %v at location %v\n\n", res.Name, res.SelfLink) // Update the bucket ID according to the resource ID d.Set("self_link", res.SelfLink) d.SetId(res.Id) return nil }
func resourceAwsMainRouteTableAssociationCreate(d *schema.ResourceData, meta interface{}) error { conn := meta.(*AWSClient).ec2conn vpcId := d.Get("vpc_id").(string) routeTableId := d.Get("route_table_id").(string) log.Printf("[INFO] Creating main route table association: %s => %s", vpcId, routeTableId) mainAssociation, err := findMainRouteTableAssociation(conn, vpcId) if err != nil { return err } resp, err := conn.ReplaceRouteTableAssociation(&ec2.ReplaceRouteTableAssociationInput{ AssociationId: mainAssociation.RouteTableAssociationId, RouteTableId: aws.String(routeTableId), }) if err != nil { return err } d.Set("original_route_table_id", mainAssociation.RouteTableId) d.SetId(*resp.NewAssociationId) log.Printf("[INFO] New main route table association ID: %s", d.Id()) return nil }
func resourceArmPublicIpRead(d *schema.ResourceData, meta interface{}) error { publicIPClient := meta.(*ArmClient).publicIPClient id, err := parseAzureResourceID(d.Id()) if err != nil { return err } resGroup := id.ResourceGroup name := id.Path["publicIPAddresses"] resp, err := publicIPClient.Get(resGroup, name, "") if resp.StatusCode == http.StatusNotFound { d.SetId("") return nil } if err != nil { return fmt.Errorf("Error making Read request on Azure public ip %s: %s", name, err) } if resp.Properties.DNSSettings != nil && resp.Properties.DNSSettings.Fqdn != nil && *resp.Properties.DNSSettings.Fqdn != "" { d.Set("fqdn", resp.Properties.DNSSettings.Fqdn) } if resp.Properties.IPAddress != nil && *resp.Properties.IPAddress != "" { d.Set("ip_address", resp.Properties.IPAddress) } flattenAndSetTags(d, resp.Tags) return nil }
func resourceComputeVpnGatewayRead(d *schema.ResourceData, meta interface{}) error { config := meta.(*Config) name := d.Get("name").(string) region := d.Get("region").(string) project := config.Project vpnGatewaysService := compute.NewTargetVpnGatewaysService(config.clientCompute) vpnGateway, err := vpnGatewaysService.Get(project, region, name).Do() if err != nil { if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 { log.Printf("[WARN] Removing VPN Gateway %q because it's gone", d.Get("name").(string)) // The resource doesn't exist anymore d.SetId("") return nil } return fmt.Errorf("Error Reading VPN Gateway %s: %s", name, err) } d.Set("self_link", vpnGateway.SelfLink) d.SetId(name) return nil }
func resourceAwsRouteTableAssociationRead(d *schema.ResourceData, meta interface{}) error { conn := meta.(*AWSClient).ec2conn // Get the routing table that this association belongs to rtRaw, _, err := resourceAwsRouteTableStateRefreshFunc( conn, d.Get("route_table_id").(string))() if err != nil { return err } if rtRaw == nil { return nil } rt := rtRaw.(*ec2.RouteTable) // Inspect that the association exists found := false for _, a := range rt.Associations { if *a.RouteTableAssociationId == d.Id() { found = true d.Set("subnet_id", *a.SubnetId) break } } if !found { // It seems it doesn't exist anymore, so clear the ID d.SetId("") } return nil }
func resourcePacketSSHKeyRead(d *schema.ResourceData, meta interface{}) error { client := meta.(*packngo.Client) key, _, err := client.SSHKeys.Get(d.Id()) if err != nil { err = friendlyError(err) // If the key is somehow already destroyed, mark as // succesfully gone if isNotFound(err) { d.SetId("") return nil } return err } d.Set("id", key.ID) d.Set("name", key.Label) d.Set("public_key", key.Key) d.Set("fingerprint", key.FingerPrint) d.Set("created", key.Created) d.Set("updated", key.Updated) return nil }
func (lt *opsworksLayerType) SetVolumeConfigurations(d *schema.ResourceData, v []*opsworks.VolumeConfiguration) { newValue := make([]*map[string]interface{}, len(v)) for i := 0; i < len(v); i++ { config := v[i] data := make(map[string]interface{}) newValue[i] = &data if config.Iops != nil { data["iops"] = int(*config.Iops) } else { data["iops"] = 0 } if config.MountPoint != nil { data["mount_point"] = *config.MountPoint } if config.NumberOfDisks != nil { data["number_of_disks"] = int(*config.NumberOfDisks) } if config.RaidLevel != nil { data["raid_level"] = strconv.Itoa(int(*config.RaidLevel)) } if config.Size != nil { data["size"] = int(*config.Size) } if config.VolumeType != nil { data["type"] = *config.VolumeType } } d.Set("ebs_volume", newValue) }