func()

in service/iam/endpoints.go [322:942]

• 582 lines of code
• 78 McCabe index (conditional complexity)

func (r *resolver) ResolveEndpoint(
	ctx context.Context, params EndpointParameters,
) (
	endpoint smithyendpoints.Endpoint, err error,
) {
	params = params.WithDefaults()
	if err = params.ValidateRequired(); err != nil {
		return endpoint, fmt.Errorf("endpoint parameters are not valid, %w", err)
	}
	_UseDualStack := *params.UseDualStack
	_UseFIPS := *params.UseFIPS

	if exprVal := params.Endpoint; exprVal != nil {
		_Endpoint := *exprVal
		_ = _Endpoint
		if _UseFIPS == true {
			return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: FIPS and custom endpoint are not supported")
		}
		if _UseDualStack == true {
			return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: Dualstack and custom endpoint are not supported")
		}
		uriString := _Endpoint

		uri, err := url.Parse(uriString)
		if err != nil {
			return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
		}

		return smithyendpoints.Endpoint{
			URI:     *uri,
			Headers: http.Header{},
		}, nil
	}
	if exprVal := params.Region; exprVal != nil {
		_Region := *exprVal
		_ = _Region
		if exprVal := awsrulesfn.GetPartition(_Region); exprVal != nil {
			_PartitionResult := *exprVal
			_ = _PartitionResult
			if _PartitionResult.Name == "aws" {
				if _UseFIPS == false {
					if _UseDualStack == true {
						uriString := "https://iam.global.api.aws"

						uri, err := url.Parse(uriString)
						if err != nil {
							return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
						}

						return smithyendpoints.Endpoint{
							URI:     *uri,
							Headers: http.Header{},
							Properties: func() smithy.Properties {
								var out smithy.Properties
								smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
									{
										SchemeID: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetSigV4SigningRegion(&sp, "us-east-1")
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
				}
			}
			if _PartitionResult.Name == "aws" {
				if _UseFIPS == true {
					if _UseDualStack == true {
						uriString := "https://iam-fips.global.api.aws"

						uri, err := url.Parse(uriString)
						if err != nil {
							return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
						}

						return smithyendpoints.Endpoint{
							URI:     *uri,
							Headers: http.Header{},
							Properties: func() smithy.Properties {
								var out smithy.Properties
								smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
									{
										SchemeID: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetSigV4SigningRegion(&sp, "us-east-1")
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
				}
			}
			if _PartitionResult.Name == "aws-cn" {
				if _UseFIPS == false {
					if _UseDualStack == true {
						uriString := "https://iam.global.api.amazonwebservices.com.cn"

						uri, err := url.Parse(uriString)
						if err != nil {
							return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
						}

						return smithyendpoints.Endpoint{
							URI:     *uri,
							Headers: http.Header{},
							Properties: func() smithy.Properties {
								var out smithy.Properties
								smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
									{
										SchemeID: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetSigV4SigningRegion(&sp, "cn-north-1")
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
				}
			}
			if _PartitionResult.Name == "aws-cn" {
				if _UseFIPS == false {
					if _UseDualStack == false {
						uriString := "https://iam.cn-north-1.amazonaws.com.cn"

						uri, err := url.Parse(uriString)
						if err != nil {
							return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
						}

						return smithyendpoints.Endpoint{
							URI:     *uri,
							Headers: http.Header{},
							Properties: func() smithy.Properties {
								var out smithy.Properties
								smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
									{
										SchemeID: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetSigV4SigningRegion(&sp, "cn-north-1")
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
				}
			}
			if _PartitionResult.Name == "aws-us-gov" {
				if _UseFIPS == false {
					if _UseDualStack == true {
						uriString := "https://iam.us-gov.api.aws"

						uri, err := url.Parse(uriString)
						if err != nil {
							return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
						}

						return smithyendpoints.Endpoint{
							URI:     *uri,
							Headers: http.Header{},
							Properties: func() smithy.Properties {
								var out smithy.Properties
								smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
									{
										SchemeID: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetSigV4SigningRegion(&sp, "us-gov-west-1")
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
				}
			}
			if _PartitionResult.Name == "aws-us-gov" {
				if _UseFIPS == true {
					if _UseDualStack == true {
						uriString := "https://iam.us-gov.api.aws"

						uri, err := url.Parse(uriString)
						if err != nil {
							return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
						}

						return smithyendpoints.Endpoint{
							URI:     *uri,
							Headers: http.Header{},
							Properties: func() smithy.Properties {
								var out smithy.Properties
								smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
									{
										SchemeID: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetSigV4SigningRegion(&sp, "us-gov-west-1")
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
				}
			}
			if _PartitionResult.Name == "aws-us-gov" {
				if _UseFIPS == false {
					if _UseDualStack == false {
						uriString := "https://iam.us-gov.amazonaws.com"

						uri, err := url.Parse(uriString)
						if err != nil {
							return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
						}

						return smithyendpoints.Endpoint{
							URI:     *uri,
							Headers: http.Header{},
							Properties: func() smithy.Properties {
								var out smithy.Properties
								smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
									{
										SchemeID: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetSigV4SigningRegion(&sp, "us-gov-west-1")
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
				}
			}
			if _PartitionResult.Name == "aws-us-gov" {
				if _UseFIPS == true {
					if _UseDualStack == false {
						uriString := "https://iam.us-gov.amazonaws.com"

						uri, err := url.Parse(uriString)
						if err != nil {
							return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
						}

						return smithyendpoints.Endpoint{
							URI:     *uri,
							Headers: http.Header{},
							Properties: func() smithy.Properties {
								var out smithy.Properties
								smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
									{
										SchemeID: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetSigV4SigningRegion(&sp, "us-gov-west-1")
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
				}
			}
			if _PartitionResult.Name == "aws-iso" {
				if _UseFIPS == false {
					if _UseDualStack == false {
						uriString := "https://iam.us-iso-east-1.c2s.ic.gov"

						uri, err := url.Parse(uriString)
						if err != nil {
							return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
						}

						return smithyendpoints.Endpoint{
							URI:     *uri,
							Headers: http.Header{},
							Properties: func() smithy.Properties {
								var out smithy.Properties
								smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
									{
										SchemeID: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetSigV4SigningRegion(&sp, "us-iso-east-1")
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
				}
			}
			if _PartitionResult.Name == "aws-iso" {
				if _UseFIPS == true {
					if _UseDualStack == false {
						uriString := "https://iam-fips.us-iso-east-1.c2s.ic.gov"

						uri, err := url.Parse(uriString)
						if err != nil {
							return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
						}

						return smithyendpoints.Endpoint{
							URI:     *uri,
							Headers: http.Header{},
							Properties: func() smithy.Properties {
								var out smithy.Properties
								smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
									{
										SchemeID: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetSigV4SigningRegion(&sp, "us-iso-east-1")
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
				}
			}
			if _PartitionResult.Name == "aws-iso-b" {
				if _UseFIPS == false {
					if _UseDualStack == false {
						uriString := "https://iam.us-isob-east-1.sc2s.sgov.gov"

						uri, err := url.Parse(uriString)
						if err != nil {
							return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
						}

						return smithyendpoints.Endpoint{
							URI:     *uri,
							Headers: http.Header{},
							Properties: func() smithy.Properties {
								var out smithy.Properties
								smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
									{
										SchemeID: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetSigV4SigningRegion(&sp, "us-isob-east-1")
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
				}
			}
			if _PartitionResult.Name == "aws-iso-b" {
				if _UseFIPS == true {
					if _UseDualStack == false {
						uriString := "https://iam-fips.us-isob-east-1.sc2s.sgov.gov"

						uri, err := url.Parse(uriString)
						if err != nil {
							return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
						}

						return smithyendpoints.Endpoint{
							URI:     *uri,
							Headers: http.Header{},
							Properties: func() smithy.Properties {
								var out smithy.Properties
								smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
									{
										SchemeID: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetSigV4SigningRegion(&sp, "us-isob-east-1")
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
				}
			}
			if _PartitionResult.Name == "aws-iso-e" {
				if _UseFIPS == false {
					if _UseDualStack == false {
						uriString := "https://iam.eu-isoe-west-1.cloud.adc-e.uk"

						uri, err := url.Parse(uriString)
						if err != nil {
							return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
						}

						return smithyendpoints.Endpoint{
							URI:     *uri,
							Headers: http.Header{},
							Properties: func() smithy.Properties {
								var out smithy.Properties
								smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
									{
										SchemeID: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetSigV4SigningRegion(&sp, "eu-isoe-west-1")
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
				}
			}
			if _PartitionResult.Name == "aws-iso-f" {
				if _UseFIPS == false {
					if _UseDualStack == false {
						uriString := "https://iam.us-isof-south-1.csp.hci.ic.gov"

						uri, err := url.Parse(uriString)
						if err != nil {
							return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
						}

						return smithyendpoints.Endpoint{
							URI:     *uri,
							Headers: http.Header{},
							Properties: func() smithy.Properties {
								var out smithy.Properties
								smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
									{
										SchemeID: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetSigV4SigningRegion(&sp, "us-isof-south-1")
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
				}
			}
			if _UseFIPS == true {
				if _UseDualStack == true {
					if true == _PartitionResult.SupportsFIPS {
						if true == _PartitionResult.SupportsDualStack {
							uriString := func() string {
								var out strings.Builder
								out.WriteString("https://iam-fips.")
								out.WriteString(_PartitionResult.DualStackDnsSuffix)
								return out.String()
							}()

							uri, err := url.Parse(uriString)
							if err != nil {
								return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
							}

							return smithyendpoints.Endpoint{
								URI:     *uri,
								Headers: http.Header{},
								Properties: func() smithy.Properties {
									var out smithy.Properties
									smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
										{
											SchemeID: "aws.auth#sigv4",
											SignerProperties: func() smithy.Properties {
												var sp smithy.Properties
												smithyhttp.SetSigV4SigningRegion(&sp, _PartitionResult.ImplicitGlobalRegion)
												return sp
											}(),
										},
									})
									return out
								}(),
							}, nil
						}
					}
					return endpoint, fmt.Errorf("endpoint rule error, %s", "FIPS and DualStack are enabled, but this partition does not support one or both")
				}
			}
			if _UseFIPS == true {
				if _UseDualStack == false {
					if _PartitionResult.SupportsFIPS == true {
						uriString := func() string {
							var out strings.Builder
							out.WriteString("https://iam-fips.")
							out.WriteString(_PartitionResult.DnsSuffix)
							return out.String()
						}()

						uri, err := url.Parse(uriString)
						if err != nil {
							return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
						}

						return smithyendpoints.Endpoint{
							URI:     *uri,
							Headers: http.Header{},
							Properties: func() smithy.Properties {
								var out smithy.Properties
								smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
									{
										SchemeID: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetSigV4SigningRegion(&sp, _PartitionResult.ImplicitGlobalRegion)
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
					return endpoint, fmt.Errorf("endpoint rule error, %s", "FIPS is enabled but this partition does not support FIPS")
				}
			}
			if _UseFIPS == false {
				if _UseDualStack == true {
					if true == _PartitionResult.SupportsDualStack {
						uriString := func() string {
							var out strings.Builder
							out.WriteString("https://iam.")
							out.WriteString(_PartitionResult.DualStackDnsSuffix)
							return out.String()
						}()

						uri, err := url.Parse(uriString)
						if err != nil {
							return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
						}

						return smithyendpoints.Endpoint{
							URI:     *uri,
							Headers: http.Header{},
							Properties: func() smithy.Properties {
								var out smithy.Properties
								smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
									{
										SchemeID: "aws.auth#sigv4",
										SignerProperties: func() smithy.Properties {
											var sp smithy.Properties
											smithyhttp.SetSigV4SigningRegion(&sp, _PartitionResult.ImplicitGlobalRegion)
											return sp
										}(),
									},
								})
								return out
							}(),
						}, nil
					}
					return endpoint, fmt.Errorf("endpoint rule error, %s", "DualStack is enabled but this partition does not support DualStack")
				}
			}
			uriString := func() string {
				var out strings.Builder
				out.WriteString("https://iam.")
				out.WriteString(_PartitionResult.DnsSuffix)
				return out.String()
			}()

			uri, err := url.Parse(uriString)
			if err != nil {
				return endpoint, fmt.Errorf("Failed to parse uri: %s", uriString)
			}

			return smithyendpoints.Endpoint{
				URI:     *uri,
				Headers: http.Header{},
				Properties: func() smithy.Properties {
					var out smithy.Properties
					smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
						{
							SchemeID: "aws.auth#sigv4",
							SignerProperties: func() smithy.Properties {
								var sp smithy.Properties
								smithyhttp.SetSigV4SigningRegion(&sp, _PartitionResult.ImplicitGlobalRegion)
								return sp
							}(),
						},
					})
					return out
				}(),
			}, nil
		}
		return endpoint, fmt.Errorf("Endpoint resolution failed. Invalid operation or environment input.")
	}
	return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: Missing Region")
}