func()

in tools/instance_mapper/instance_mapper.go [448:557]

• 101 lines of code
• 19 McCabe index (conditional complexity)

func (im *InstanceMapper) LoadGCPCloudSQLInstanceTypes(ctx context.Context, projectId string, sqlMap *SQLMap, debug bool) error {
	im.InstanceData.GcpSqlInstances = make(map[string]map[string]InstanceType, 0)
	im.InstanceData.GcpSqlInstances["all"] = make(map[string]InstanceType, 0)

	httpClient, err := im.getHttpClient(ctx, debug)
	if err != nil {
		return err
	}

	c, err := compute.NewRegionsRESTClient(ctx, option.WithHTTPClient(httpClient))
	if err != nil {
		return err
	}
	defer c.Close()

	regions := make([]string, 0)
	req := &computepb.ListRegionsRequest{
		Project: projectId,
	}
	it := c.List(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		regions = append(regions, *resp.Name)
	}

	sqladminService, err := sqladmin.NewService(ctx, option.WithHTTPClient(httpClient))
	if err != nil {
		return err
	}

	databaseVersions := make([]DatabaseVersion, 0)
	flagsService := sqladmin.NewFlagsService(sqladminService)
	flagsListCall := flagsService.List()
	flagsResponse, err := flagsListCall.Do()
	if err != nil {
		return err
	}
	for _, flag := range flagsResponse.Items {
		for _, dbVersion := range flag.AppliesTo {
			var engine, majorVersion, minorVersion string
			dbVersionLower := strings.ToLower(dbVersion)
			if mapped, found := sqlMap.Mapping[dbVersionLower]; found {
				engine = mapped.Engine
				majorVersion = mapped.Major
				minorVersion = mapped.Minor
			} else {
				log.Infof("No SQL mapping for for type: %s, parsing manually...", dbVersionLower)
				dbVersionA := strings.SplitN(dbVersion, "_", 3)
				engine = strings.ToLower(dbVersionA[0])
				majorVersion = dbVersionA[1]
				minorVersion = "0"
				if len(dbVersionA) > 2 {
					minorVersion = dbVersionA[2]
				}
			}
			v := DatabaseVersion{
				DatabaseType:         engine,
				DatabaseMajorVersion: majorVersion,
				DatabaseMinorVersion: minorVersion,
				DatabaseOriginal:     dbVersion,
			}
			if !im.databaseVersionInSlice(v, databaseVersions) {
				log.Infof("Discovered database type %s (version %s.%s)\n", v.DatabaseType, v.DatabaseMajorVersion, v.DatabaseMinorVersion)
				databaseVersions = append(databaseVersions, v)
			}
		}
	}

	tiersService := sqladmin.NewTiersService(sqladminService)
	tiersListCall := tiersService.List(projectId)
	tiersResponse, err := tiersListCall.Do()
	if err != nil {
		return err
	}

	for _, tier := range tiersResponse.Items {
		realInstanceType := strings.TrimPrefix(tier.Tier, "db-")
		if _, found := im.InstanceData.GcpInstances["all"][realInstanceType]; !found {
			log.Warningf("No matching GCP instance type found for Cloud SQL instance type: %s, skipping...", tier.Tier)
			continue
		}
		for _, dbVersion := range databaseVersions {
			it := im.InstanceData.GcpInstances["all"][realInstanceType]
			it.InstanceTypeId = tier.Tier
			it.DatabaseType = dbVersion.DatabaseType
			it.DatabaseMajorVersion = dbVersion.DatabaseMajorVersion
			it.DatabaseMinorVersion = dbVersion.DatabaseMinorVersion
			it.DatabaseOriginal = dbVersion.DatabaseOriginal

			instanceKey := fmt.Sprintf("%s-%s", it.InstanceTypeId, it.DatabaseOriginal)

			for _, RegionName := range regions {
				if _, found := im.InstanceData.GcpSqlInstances[RegionName]; !found {
					im.InstanceData.GcpSqlInstances[RegionName] = make(map[string]InstanceType, 0)
				}
				it.Region = RegionName
				im.InstanceData.GcpSqlInstances[it.Region][instanceKey] = it
			}
			im.InstanceData.GcpSqlInstances["all"][instanceKey] = it
			log.Infof("GCP Cloud SQL instance type: %s\n", it.String())
		}
	}
	return nil
}