func()

in providers/ibm/ibm_private_dns.go [167:323]
133 lines of code
22 McCabe index (conditional complexity)

func (g *privateDNSTemplateGenerator) InitResources() error {

	region := g.Args["region"].(string)
	bmxConfig := &bluemix.Config{
		BluemixAPIKey: os.Getenv("IC_API_KEY"),
		Region:        region,
	}
	sess, err := session.New(bmxConfig)
	if err != nil {
		return err
	}
	defaultDNSURL := "https://api.dns-svcs.cloud.ibm.com/v1"

	err = authenticateAPIKey(sess)
	if err != nil {
		return err
	}

	bluemixToken := ""
	if strings.HasPrefix(sess.Config.IAMAccessToken, "Bearer") {
		bluemixToken = sess.Config.IAMAccessToken[7:len(sess.Config.IAMAccessToken)]
	} else {
		bluemixToken = sess.Config.IAMAccessToken
	}

	catalogClient, err := catalog.New(sess)
	if err != nil {
		return err
	}

	controllerClient, err := controllerv2.New(sess)
	if err != nil {
		return err
	}

	serviceID, err := catalogClient.ResourceCatalog().FindByName("dns-svcs", true)
	if err != nil {
		return err
	}
	query := controllerv2.ServiceInstanceQuery{
		ServiceID: serviceID[0].ID,
	}
	pDNSInstances, err := controllerClient.ResourceServiceInstanceV2().ListInstances(query)
	if err != nil {
		return err
	}

	for _, instance := range pDNSInstances {
		instanceID := instance.ID
		instanceGUID := instance.Guid
		// Instance
		fnObjt := g.loadPrivateDNS()
		g.Resources = append(g.Resources, fnObjt(instanceID, instance.Name, instance.ResourceGroupID))
		resourceName := g.Resources[len(g.Resources)-1:][0].ResourceName
		var pDNSDependsOn []string
		pDNSDependsOn = append(pDNSDependsOn,
			"ibm_resource_instance."+resourceName)

		// Zones
		zoneOpts := &dns.DnsSvcsV1Options{
			URL: defaultDNSURL,
			Authenticator: &core.BearerTokenAuthenticator{
				BearerToken: bluemixToken,
			},
		}

		zService, err := dns.NewDnsSvcsV1(zoneOpts)
		if err != nil {
			return err
		}
		zoneOpt := dns.ListDnszonesOptions{
			InstanceID: &instanceGUID,
		}
		zoneList, _, err := zService.ListDnszones(&zoneOpt)
		if err != nil {
			return fmt.Errorf("error Listing Zones %s", err)
		}
		for _, zone := range zoneList.Dnszones {
			zoneID := *zone.ID
			g.Resources = append(g.Resources, g.loadPrivateDNSZone(instanceGUID, zoneID, pDNSDependsOn))
			domainResourceName := g.Resources[len(g.Resources)-1:][0].ResourceName
			domainDependsOn := makeDependsOn(pDNSDependsOn, "ibm_dns_zone."+domainResourceName)

			// Permitted Network Records
			permittedNetworkOpt := dns.ListPermittedNetworksOptions{
				InstanceID: &instanceGUID,
				DnszoneID:  &zoneID,
			}
			permittedNetworkList, _, err := zService.ListPermittedNetworks(&permittedNetworkOpt)
			if err != nil {
				return fmt.Errorf("error Listing Permitted Networks %s", err)
			}
			for _, permittedNetwork := range permittedNetworkList.PermittedNetworks {
				permittedNetworkID := *permittedNetwork.ID
				g.Resources = append(g.Resources, g.loadPrivateDNSPermittedNetwork(instanceGUID, zoneID, permittedNetworkID, domainDependsOn))
			}

			// Resource Records
			dnsRecordOpt := dns.ListResourceRecordsOptions{
				InstanceID: &instanceGUID,
				DnszoneID:  &zoneID,
			}
			resourceRecordList, _, err := zService.ListResourceRecords(&dnsRecordOpt)
			if err != nil {
				return fmt.Errorf("error Listing Resource Records %s", err)
			}

			pdnsFnObjt := g.loadPrivateDNSResourceRecord()
			for _, record := range resourceRecordList.ResourceRecords {
				g.Resources = append(g.Resources, pdnsFnObjt(instanceGUID, zoneID, *record.ID, *record.Name, domainDependsOn))
			}

			// GLB Records
			glbOpt := dns.ListLoadBalancersOptions{
				InstanceID: &instanceGUID,
				DnszoneID:  &zoneID,
			}
			glbOptList, _, err := zService.ListLoadBalancers(&glbOpt)
			if err != nil {
				return fmt.Errorf("error Listing GLBs %s", err)
			}
			glbFntObj := g.loadPrivateDNSGLB()
			for _, lb := range glbOptList.LoadBalancers {
				g.Resources = append(g.Resources, glbFntObj(instanceGUID, zoneID, *lb.ID, *lb.Name, domainDependsOn))
			}
		}
		// Monitor Records
		monitorOpt := dns.ListMonitorsOptions{
			InstanceID: &instanceGUID,
		}
		glbMonitorList, _, err := zService.ListMonitors(&monitorOpt)
		if err != nil {
			return fmt.Errorf("error Listing GLB Monitor %s", err)
		}

		lbMonitorObjt := g.loadPrivateDNSGLBMonitor()
		for _, monitor := range glbMonitorList.Monitors {
			g.Resources = append(g.Resources, lbMonitorObjt(instanceGUID, *monitor.ID, *monitor.Name, pDNSDependsOn))
		}

		// Pool Records
		glbPoolOpt := dns.ListPoolsOptions{
			InstanceID: &instanceGUID,
		}
		glbPoolOptList, _, err := zService.ListPools(&glbPoolOpt)
		if err != nil {
			return fmt.Errorf("error Listing GLB Pools %s", err)
		}
		dnsGlbfnObj := g.loadPrivateDNSGLBPool()
		for _, pool := range glbPoolOptList.Pools {
			g.Resources = append(g.Resources, dnsGlbfnObj(instanceGUID, *pool.ID, *pool.Name, pDNSDependsOn))
		}

	}

	return nil
}