Merge pull request #7835 from r4f4/aws-validate-instance-arch

OCPBUGS-25600: aws: validate instance arch

Author: openshift-merge-bot[bot]

pkg/asset/installconfig/aws/availabilityzones.go

@@ -7,7 +7,6 @@ import (
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/pkg/errors"
 
 	typesaws "github.com/openshift/installer/pkg/types/aws"
 )
@@ -64,7 +63,7 @@ func describeAvailabilityZones(ctx context.Context, session *session.Session, re
 	}
 	resp, err := client.DescribeAvailabilityZonesWithContext(ctx, input)
 	if err != nil {
-		return nil, errors.Wrap(err, "fetching zones")
+		return nil, fmt.Errorf("fetching zones: %w", err)
 	}
 
 	return resp.AvailabilityZones, nil
@@ -75,7 +74,7 @@ func describeAvailabilityZones(ctx context.Context, session *session.Session, re
 func filterZonesByType(ctx context.Context, session *session.Session, region string, zoneType string) ([]string, error) {
 	azs, err := describeAvailabilityZones(ctx, session, region, []string{})
 	if err != nil {
-		return nil, errors.Wrapf(err, "fetching %s", zoneType)
+		return nil, fmt.Errorf("fetching %s: %w", zoneType, err)
 	}
 	zones := []string{}
 	for _, zone := range azs {
@@ -85,7 +84,7 @@ func filterZonesByType(ctx context.Context, session *session.Session, region str
 	}
 
 	if len(zones) == 0 {
-		return nil, errors.Errorf("no zones with type %s in %s", zoneType, region)
+		return nil, fmt.Errorf("no zones with type %s in %s", zoneType, region)
 	}
 
 	return zones, nil
@@ -118,7 +117,7 @@ func edgeZones(ctx context.Context, session *session.Session, region string) ([]
 func describeFilteredZones(ctx context.Context, session *session.Session, region string, zones []string) ([]*ec2.AvailabilityZone, error) {
 	azs, err := describeAvailabilityZones(ctx, session, region, zones)
 	if err != nil {
-		return nil, errors.Wrapf(err, "fetching %s", zones)
+		return nil, fmt.Errorf("fetching %s: %w", zones, err)
 	}
 
 	return azs, nil

pkg/asset/installconfig/aws/basedomain.go

@@ -1,6 +1,8 @@
 package aws
 
 import (
+	"errors"
+	"fmt"
 	"net/http"
 	"sort"
 	"strings"
@@ -11,15 +13,14 @@ import (
 	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/aws/aws-sdk-go/service/route53"
-	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 )
 
 // IsForbidden returns true if and only if the input error is an HTTP
 // 403 error from the AWS API.
 func IsForbidden(err error) bool {
-	requestError, ok := err.(awserr.RequestFailure)
-	return ok && requestError.StatusCode() == http.StatusForbidden
+	var requestError awserr.RequestFailure
+	return errors.As(err, &requestError) && requestError.StatusCode() == http.StatusForbidden
 }
 
 // GetBaseDomain returns a base domain chosen from among the account's
@@ -45,7 +46,7 @@ func GetBaseDomain() (string, error) {
 			return !lastPage
 		},
 	); err != nil {
-		return "", errors.Wrap(err, "list hosted zones")
+		return "", fmt.Errorf("list hosted zones: %w", err)
 	}
 
 	publicZones := make([]string, 0, len(publicZoneMap))
@@ -69,12 +70,12 @@ func GetBaseDomain() (string, error) {
 			choice := ans.(core.OptionAnswer).Value
 			i := sort.SearchStrings(publicZones, choice)
 			if i == len(publicZones) || publicZones[i] != choice {
-				return errors.Errorf("invalid base domain %q", choice)
+				return fmt.Errorf("invalid base domain %q", choice)
 			}
 			return nil
 		}),
 	); err != nil {
-		return "", errors.Wrap(err, "failed UserInput")
+		return "", fmt.Errorf("failed UserInput: %w", err)
 	}
 
 	return domain, nil
@@ -95,10 +96,10 @@ func GetPublicZone(sess *session.Session, name string) (*route53.HostedZone, err
 
 	client := route53.New(sess)
 	if err := client.ListHostedZonesPages(&route53.ListHostedZonesInput{}, f); err != nil {
-		return nil, errors.Wrap(err, "listing hosted zones")
+		return nil, fmt.Errorf("listing hosted zones: %w", err)
 	}
 	if res == nil {
-		return nil, errors.Errorf("No public route53 zone found matching name %q", name)
+		return nil, fmt.Errorf("no public route53 zone found matching name %q", name)
 	}
 	return res, nil
 }

pkg/asset/installconfig/aws/instancetypes.go

@@ -2,17 +2,18 @@ package aws
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/aws/aws-sdk-go/service/ec2"
-	"github.com/pkg/errors"
 )
 
 // InstanceType holds metadata for an instance type.
 type InstanceType struct {
 	DefaultVCpus int64
 	MemInMiB     int64
+	Arches       []string
 }
 
 // instanceTypes retrieves a list of instance types for the given region.
@@ -27,11 +28,12 @@ func instanceTypes(ctx context.Context, session *session.Session, region string)
 				types[*info.InstanceType] = InstanceType{
 					DefaultVCpus: aws.Int64Value(info.VCpuInfo.DefaultVCpus),
 					MemInMiB:     aws.Int64Value(info.MemoryInfo.SizeInMiB),
+					Arches:       aws.StringValueSlice(info.ProcessorInfo.SupportedArchitectures),
 				}
 			}
 			return !lastPage
 		}); err != nil {
-		return nil, errors.Wrap(err, "fetching instance types")
+		return nil, fmt.Errorf("fetching instance types: %w", err)
 	}
 
 	return types, nil

pkg/asset/installconfig/aws/metadata.go

@@ -2,11 +2,12 @@ package aws
 
 import (
 	"context"
+	"errors"
+	"fmt"
 	"sync"
 
 	awssdk "github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/pkg/errors"
 
 	typesaws "github.com/openshift/installer/pkg/types/aws"
 )
@@ -50,7 +51,7 @@ func (m *Metadata) unlockedSession(ctx context.Context) (*session.Session, error
 		var err error
 		m.session, err = GetSessionWithOptions(WithRegion(m.Region), WithServiceEndpoints(m.Region, m.Services))
 		if err != nil {
-			return nil, errors.Wrap(err, "creating AWS session")
+			return nil, fmt.Errorf("creating AWS session: %w", err)
 		}
 	}
 
@@ -69,7 +70,7 @@ func (m *Metadata) AvailabilityZones(ctx context.Context) ([]string, error) {
 		}
 		m.availabilityZones, err = availabilityZones(ctx, session, m.Region)
 		if err != nil {
-			return nil, errors.Wrap(err, "error retrieving Availability Zones")
+			return nil, fmt.Errorf("error retrieving Availability Zones: %w", err)
 		}
 	}
 
@@ -89,7 +90,7 @@ func (m *Metadata) EdgeZones(ctx context.Context) ([]string, error) {
 
 		m.edgeZones, err = edgeZones(ctx, session, m.Region)
 		if err != nil {
-			return nil, errors.Wrap(err, "getting Local Zones")
+			return nil, fmt.Errorf("getting Local Zones: %w", err)
 		}
 	}
 
@@ -102,7 +103,7 @@ func (m *Metadata) EdgeZones(ctx context.Context) ([]string, error) {
 func (m *Metadata) EdgeSubnets(ctx context.Context) (Subnets, error) {
 	err := m.populateSubnets(ctx)
 	if err != nil {
-		return nil, errors.Wrap(err, "error retrieving Edge Subnets")
+		return nil, fmt.Errorf("error retrieving Edge Subnets: %w", err)
 	}
 	return m.edgeSubnets, nil
 }
@@ -111,11 +112,11 @@ func (m *Metadata) EdgeSubnets(ctx context.Context) (Subnets, error) {
 func (m *Metadata) SetZoneAttributes(ctx context.Context, zoneNames []string, zones Zones) error {
 	sess, err := m.Session(ctx)
 	if err != nil {
-		return errors.Wrap(err, "unable to get aws session to populate zone details")
+		return fmt.Errorf("unable to get aws session to populate zone details: %w", err)
 	}
 	azs, err := describeFilteredZones(ctx, sess, m.Region, zoneNames)
 	if err != nil {
-		return errors.Wrap(err, "unable to filter zones")
+		return fmt.Errorf("unable to filter zones: %w", err)
 	}
 
 	for _, az := range azs {
@@ -140,11 +141,11 @@ func (m *Metadata) SetZoneAttributes(ctx context.Context, zoneNames []string, zo
 func (m *Metadata) AllZones(ctx context.Context) (Zones, error) {
 	sess, err := m.Session(ctx)
 	if err != nil {
-		return nil, errors.Wrap(err, "unable to get aws session to populate zone details")
+		return nil, fmt.Errorf("unable to get aws session to populate zone details: %w", err)
 	}
 	azs, err := describeAvailabilityZones(ctx, sess, m.Region, []string{})
 	if err != nil {
-		return nil, errors.Wrap(err, "unable to gather availability zones")
+		return nil, fmt.Errorf("unable to gather availability zones: %w", err)
 	}
 	zoneDesc := make(Zones, len(azs))
 	for _, az := range azs {
@@ -167,7 +168,7 @@ func (m *Metadata) AllZones(ctx context.Context) (Zones, error) {
 func (m *Metadata) PrivateSubnets(ctx context.Context) (Subnets, error) {
 	err := m.populateSubnets(ctx)
 	if err != nil {
-		return nil, errors.Wrap(err, "error retrieving Private Subnets")
+		return nil, fmt.Errorf("error retrieving Private Subnets: %w", err)
 	}
 	return m.privateSubnets, nil
 }
@@ -178,7 +179,7 @@ func (m *Metadata) PrivateSubnets(ctx context.Context) (Subnets, error) {
 func (m *Metadata) PublicSubnets(ctx context.Context) (Subnets, error) {
 	err := m.populateSubnets(ctx)
 	if err != nil {
-		return nil, errors.Wrap(err, "error retrieving Public Subnets")
+		return nil, fmt.Errorf("error retrieving Public Subnets: %w", err)
 	}
 	return m.publicSubnets, nil
 }
@@ -187,7 +188,7 @@ func (m *Metadata) PublicSubnets(ctx context.Context) (Subnets, error) {
 func (m *Metadata) VPC(ctx context.Context) (string, error) {
 	err := m.populateSubnets(ctx)
 	if err != nil {
-		return "", errors.Wrap(err, "error retrieving VPC")
+		return "", fmt.Errorf("error retrieving VPC: %w", err)
 	}
 	return m.vpc, nil
 }
@@ -231,7 +232,7 @@ func (m *Metadata) InstanceTypes(ctx context.Context) (map[string]InstanceType,
 
 		m.instanceTypes, err = instanceTypes(ctx, session, m.Region)
 		if err != nil {
-			return nil, errors.Wrap(err, "error listing instance types")
+			return nil, fmt.Errorf("error listing instance types: %w", err)
 		}
 	}
 

pkg/asset/installconfig/aws/permissions.go

@@ -2,9 +2,11 @@
 package aws
 
 import (
+	"errors"
+	"fmt"
+
 	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/aws/aws-sdk-go/service/iam"
-	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 
 	ccaws "github.com/openshift/cloud-credential-operator/pkg/aws"
@@ -270,14 +272,14 @@ func ValidateCreds(ssn *session.Session, groups []PermissionGroup, region string
 	for _, group := range groups {
 		groupPerms, ok := permissions[group]
 		if !ok {
-			return errors.Errorf("unable to access permissions group %s", group)
+			return fmt.Errorf("unable to access permissions group %s", group)
 		}
 		requiredPermissions = append(requiredPermissions, groupPerms...)
 	}
 
 	client, err := ccaws.NewClientFromIAMClient(iam.New(ssn))
 	if err != nil {
-		return errors.Wrap(err, "failed to create client for permission check")
+		return fmt.Errorf("failed to create client for permission check: %w", err)
 	}
 
 	sParams := &ccaws.SimulateParams{
@@ -288,7 +290,7 @@ func ValidateCreds(ssn *session.Session, groups []PermissionGroup, region string
 	logger := logrus.StandardLogger()
 	canInstall, err := ccaws.CheckPermissionsAgainstActions(client, requiredPermissions, sParams, logger)
 	if err != nil {
-		return errors.Wrap(err, "checking install permissions")
+		return fmt.Errorf("checking install permissions: %w", err)
 	}
 	if !canInstall {
 		return errors.New("current credentials insufficient for performing cluster installation")
@@ -297,7 +299,7 @@ func ValidateCreds(ssn *session.Session, groups []PermissionGroup, region string
 	// Check whether we can mint new creds for cluster services needing to interact with the cloud
 	canMint, err := ccaws.CheckCloudCredCreation(client, logger)
 	if err != nil {
-		return errors.Wrap(err, "mint credentials check")
+		return fmt.Errorf("mint credentials check: %w", err)
 	}
 	if canMint {
 		return nil
@@ -307,7 +309,7 @@ func ValidateCreds(ssn *session.Session, groups []PermissionGroup, region string
 	// cluster services needing to interact with the cloud
 	canPassthrough, err := ccaws.CheckCloudCredPassthrough(client, sParams, logger)
 	if err != nil {
-		return errors.Wrap(err, "passthrough credentials check")
+		return fmt.Errorf("passthrough credentials check: %w", err)
 	}
 	if canPassthrough {
 		return nil

pkg/asset/installconfig/aws/platform.go

@@ -7,7 +7,6 @@ import (
 
 	survey "github.com/AlecAivazis/survey/v2"
 	"github.com/AlecAivazis/survey/v2/core"
-	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 
 	"github.com/openshift/installer/pkg/types/aws"
@@ -69,7 +68,7 @@ func Platform() (*aws.Platform, error) {
 				choice := regionTransform(ans).(core.OptionAnswer).Value
 				i := sort.SearchStrings(shortRegions, choice)
 				if i == len(shortRegions) || shortRegions[i] != choice {
-					return errors.Errorf("invalid region %q", choice)
+					return fmt.Errorf("invalid region %q", choice)
 				}
 				return nil
 			}),

pkg/asset/installconfig/aws/route53.go

@@ -9,7 +9,6 @@ import (
 	"github.com/aws/aws-sdk-go/aws/endpoints"
 	awss "github.com/aws/aws-sdk-go/aws/session"
 	"github.com/aws/aws-sdk-go/service/route53"
-	"github.com/pkg/errors"
 	"k8s.io/apimachinery/pkg/util/validation/field"
 
 	"github.com/openshift/installer/pkg/types"
@@ -46,7 +45,7 @@ func (c *Client) GetHostedZone(hostedZone string, cfg *aws.Config) (*route53.Get
 	// validate that the hosted zone exists
 	hostedZoneOutput, err := r53.GetHostedZone(&route53.GetHostedZoneInput{Id: aws.String(hostedZone)})
 	if err != nil {
-		return nil, errors.Wrapf(err, "could not get hosted zone: %s", hostedZone)
+		return nil, fmt.Errorf("could not get hosted zone: %s: %w", hostedZone, err)
 	}
 	return hostedZoneOutput, nil
 }
@@ -58,7 +57,7 @@ func (c *Client) ValidateZoneRecords(zone *route53.HostedZone, zoneName string,
 	problematicRecords, err := c.GetSubDomainDNSRecords(zone, ic, cfg)
 	if err != nil {
 		allErrs = append(allErrs, field.InternalError(zonePath,
-			errors.Wrapf(err, "could not list record sets for domain %q", zoneName)))
+			fmt.Errorf("could not list record sets for domain %q: %w", zoneName, err)))
 	}
 
 	if len(problematicRecords) > 0 {
@@ -79,7 +78,7 @@ func (c *Client) GetSubDomainDNSRecords(hostedZone *route53.HostedZone, ic *type
 
 	// validate that the domain of the hosted zone is the cluster domain or a parent of the cluster domain
 	if !isHostedZoneDomainParentOfClusterDomain(hostedZone, dottedClusterDomain) {
-		return nil, errors.Errorf("hosted zone domain %q is not a parent of the cluster domain %q", *hostedZone.Name, dottedClusterDomain)
+		return nil, fmt.Errorf("hosted zone domain %q is not a parent of the cluster domain %q", *hostedZone.Name, dottedClusterDomain)
 	}
 
 	r53 := route53.New(c.ssn, cfg)
@@ -132,7 +131,7 @@ func isHostedZoneDomainParentOfClusterDomain(hostedZone *route53.HostedZone, dot
 func (c *Client) GetBaseDomain(baseDomainName string) (*route53.HostedZone, error) {
 	baseDomainZone, err := GetPublicZone(c.ssn, baseDomainName)
 	if err != nil {
-		return nil, errors.Wrapf(err, "could not find public zone: %s", baseDomainName)
+		return nil, fmt.Errorf("could not find public zone: %s: %w", baseDomainName, err)
 	}
 	return baseDomainZone, nil
 }