func()

in service/dynamodb/endpoints.go [349:725]

• 355 lines of code
• 73 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 _Region == "local" {
				if _UseFIPS == true {
					return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: FIPS and local endpoint are not supported")
				}
				if _UseDualStack == true {
					return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: Dualstack and local endpoint are not supported")
				}
				uriString := "http://localhost:8000"

				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")

									smithyhttp.SetSigV4SigningName(&sp, "dynamodb")
									smithyhttp.SetSigV4ASigningName(&sp, "dynamodb")
									return sp
								}(),
							},
						})
						return out
					}(),
				}, nil
			}
			if _UseFIPS == true {
				if _UseDualStack == true {
					if _PartitionResult.SupportsFIPS == true {
						if _PartitionResult.SupportsDualStack == true {
							if exprVal := params.AccountIdEndpointMode; exprVal != nil {
								_AccountIdEndpointMode := *exprVal
								_ = _AccountIdEndpointMode
								if _AccountIdEndpointMode == "required" {
									return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported")
								}
							}
							uriString := func() string {
								var out strings.Builder
								out.WriteString("https://dynamodb-fips.")
								out.WriteString(_Region)
								out.WriteString(".")
								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{},
							}, 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 _PartitionResult.SupportsFIPS == true {
					if _PartitionResult.Name == "aws-us-gov" {
						if exprVal := params.AccountIdEndpointMode; exprVal != nil {
							_AccountIdEndpointMode := *exprVal
							_ = _AccountIdEndpointMode
							if _AccountIdEndpointMode == "required" {
								return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported")
							}
						}
						uriString := func() string {
							var out strings.Builder
							out.WriteString("https://dynamodb.")
							out.WriteString(_Region)
							out.WriteString(".")
							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{},
						}, nil
					}
					if exprVal := params.AccountIdEndpointMode; exprVal != nil {
						_AccountIdEndpointMode := *exprVal
						_ = _AccountIdEndpointMode
						if _AccountIdEndpointMode == "required" {
							return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported")
						}
					}
					uriString := func() string {
						var out strings.Builder
						out.WriteString("https://dynamodb-fips.")
						out.WriteString(_Region)
						out.WriteString(".")
						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{},
					}, nil
				}
				return endpoint, fmt.Errorf("endpoint rule error, %s", "FIPS is enabled but this partition does not support FIPS")
			}
			if _UseDualStack == true {
				if _PartitionResult.SupportsDualStack == true {
					if exprVal := params.AccountIdEndpointMode; exprVal != nil {
						_AccountIdEndpointMode := *exprVal
						_ = _AccountIdEndpointMode
						if _AccountIdEndpointMode == "required" {
							if !(_UseFIPS == true) {
								return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: AccountIdEndpointMode is required and DualStack is enabled, but DualStack account endpoints are not supported")
							}
							return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported")
						}
					}
					uriString := func() string {
						var out strings.Builder
						out.WriteString("https://dynamodb.")
						out.WriteString(_Region)
						out.WriteString(".")
						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{},
					}, nil
				}
				return endpoint, fmt.Errorf("endpoint rule error, %s", "DualStack is enabled but this partition does not support DualStack")
			}
			if exprVal := params.AccountIdEndpointMode; exprVal != nil {
				_AccountIdEndpointMode := *exprVal
				_ = _AccountIdEndpointMode
				if !(_AccountIdEndpointMode == "disabled") {
					if _PartitionResult.Name == "aws" {
						if !(_UseFIPS == true) {
							if !(_UseDualStack == true) {
								if exprVal := params.ResourceArn; exprVal != nil {
									_ResourceArn := *exprVal
									_ = _ResourceArn
									if exprVal := awsrulesfn.ParseARN(_ResourceArn); exprVal != nil {
										_ParsedArn := *exprVal
										_ = _ParsedArn
										if _ParsedArn.Service == "dynamodb" {
											if rulesfn.IsValidHostLabel(_ParsedArn.Region, false) {
												if _ParsedArn.Region == _Region {
													if rulesfn.IsValidHostLabel(_ParsedArn.AccountId, false) {
														uriString := func() string {
															var out strings.Builder
															out.WriteString("https://")
															out.WriteString(_ParsedArn.AccountId)
															out.WriteString(".ddb.")
															out.WriteString(_Region)
															out.WriteString(".")
															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{},
														}, nil
													}
												}
											}
										}
									}
								}
							}
						}
					}
				}
			}
			if exprVal := params.AccountIdEndpointMode; exprVal != nil {
				_AccountIdEndpointMode := *exprVal
				_ = _AccountIdEndpointMode
				if !(_AccountIdEndpointMode == "disabled") {
					if _PartitionResult.Name == "aws" {
						if !(_UseFIPS == true) {
							if !(_UseDualStack == true) {
								if exprVal := params.ResourceArnList; exprVal != nil {
									_ResourceArnList := stringSlice(exprVal)
									_ = _ResourceArnList
									if exprVal := _ResourceArnList.Get(0); exprVal != nil {
										_FirstArn := *exprVal
										_ = _FirstArn
										if exprVal := awsrulesfn.ParseARN(_FirstArn); exprVal != nil {
											_ParsedArn := *exprVal
											_ = _ParsedArn
											if _ParsedArn.Service == "dynamodb" {
												if rulesfn.IsValidHostLabel(_ParsedArn.Region, false) {
													if _ParsedArn.Region == _Region {
														if rulesfn.IsValidHostLabel(_ParsedArn.AccountId, false) {
															uriString := func() string {
																var out strings.Builder
																out.WriteString("https://")
																out.WriteString(_ParsedArn.AccountId)
																out.WriteString(".ddb.")
																out.WriteString(_Region)
																out.WriteString(".")
																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{},
															}, nil
														}
													}
												}
											}
										}
									}
								}
							}
						}
					}
				}
			}
			if exprVal := params.AccountIdEndpointMode; exprVal != nil {
				_AccountIdEndpointMode := *exprVal
				_ = _AccountIdEndpointMode
				if !(_AccountIdEndpointMode == "disabled") {
					if _PartitionResult.Name == "aws" {
						if !(_UseFIPS == true) {
							if !(_UseDualStack == true) {
								if exprVal := params.AccountId; exprVal != nil {
									_AccountId := *exprVal
									_ = _AccountId
									if rulesfn.IsValidHostLabel(_AccountId, false) {
										uriString := func() string {
											var out strings.Builder
											out.WriteString("https://")
											out.WriteString(_AccountId)
											out.WriteString(".ddb.")
											out.WriteString(_Region)
											out.WriteString(".")
											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{},
										}, nil
									}
									return endpoint, fmt.Errorf("endpoint rule error, %s", "Credentials-sourced account ID parameter is invalid")
								}
							}
						}
					}
				}
			}
			if exprVal := params.AccountIdEndpointMode; exprVal != nil {
				_AccountIdEndpointMode := *exprVal
				_ = _AccountIdEndpointMode
				if _AccountIdEndpointMode == "required" {
					if !(_UseFIPS == true) {
						if !(_UseDualStack == true) {
							if _PartitionResult.Name == "aws" {
								return endpoint, fmt.Errorf("endpoint rule error, %s", "AccountIdEndpointMode is required but no AccountID was provided or able to be loaded")
							}
							return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition")
						}
						return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: AccountIdEndpointMode is required and DualStack is enabled, but DualStack account endpoints are not supported")
					}
					return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported")
				}
			}
			uriString := func() string {
				var out strings.Builder
				out.WriteString("https://dynamodb.")
				out.WriteString(_Region)
				out.WriteString(".")
				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{},
			}, 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")
}