func()

in service/kinesis/endpoints.go [343:1030]
651 lines of code
103 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.StreamARN; exprVal != nil {
		_StreamARN := *exprVal
		_ = _StreamARN
		if !(params.Endpoint != nil) {
			if exprVal := params.Region; exprVal != nil {
				_Region := *exprVal
				_ = _Region
				if exprVal := awsrulesfn.GetPartition(_Region); exprVal != nil {
					_PartitionResult := *exprVal
					_ = _PartitionResult
					if !(_PartitionResult.Name == "aws-iso") {
						if !(_PartitionResult.Name == "aws-iso-b") {
							if exprVal := awsrulesfn.ParseARN(_StreamARN); exprVal != nil {
								_arn := *exprVal
								_ = _arn
								if rulesfn.IsValidHostLabel(_arn.AccountId, false) {
									if rulesfn.IsValidHostLabel(_arn.Region, false) {
										if _arn.Service == "kinesis" {
											if exprVal := _arn.ResourceId.Get(0); exprVal != nil {
												_arnType := *exprVal
												_ = _arnType
												if !(_arnType == "") {
													if _arnType == "stream" {
														if _PartitionResult.Name == _arn.Partition {
															if exprVal := params.OperationType; exprVal != nil {
																_OperationType := *exprVal
																_ = _OperationType
																if _UseFIPS == true {
																	if _UseDualStack == true {
																		if _PartitionResult.SupportsFIPS == true {
																			if _PartitionResult.SupportsDualStack == true {
																				uriString := func() string {
																					var out strings.Builder
																					out.WriteString("https://")
																					out.WriteString(_arn.AccountId)
																					out.WriteString(".")
																					out.WriteString(_OperationType)
																					out.WriteString("-kinesis-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", "DualStack is enabled, but this partition does not support DualStack.")
																		}
																		return endpoint, fmt.Errorf("endpoint rule error, %s", "FIPS is enabled, but this partition does not support FIPS.")
																	}
																}
																if _UseFIPS == true {
																	if _PartitionResult.SupportsFIPS == true {
																		uriString := func() string {
																			var out strings.Builder
																			out.WriteString("https://")
																			out.WriteString(_arn.AccountId)
																			out.WriteString(".")
																			out.WriteString(_OperationType)
																			out.WriteString("-kinesis-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 {
																		uriString := func() string {
																			var out strings.Builder
																			out.WriteString("https://")
																			out.WriteString(_arn.AccountId)
																			out.WriteString(".")
																			out.WriteString(_OperationType)
																			out.WriteString("-kinesis.")
																			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")
																}
																uriString := func() string {
																	var out strings.Builder
																	out.WriteString("https://")
																	out.WriteString(_arn.AccountId)
																	out.WriteString(".")
																	out.WriteString(_OperationType)
																	out.WriteString("-kinesis.")
																	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", "Operation Type is not set. Please contact service team for resolution.")
														}
														return endpoint, fmt.Errorf("endpoint rule error, %s", func() string {
															var out strings.Builder
															out.WriteString("Partition: ")
															out.WriteString(_arn.Partition)
															out.WriteString(" from ARN doesn't match with partition name: ")
															out.WriteString(_PartitionResult.Name)
															out.WriteString(".")
															return out.String()
														}())
													}
													return endpoint, fmt.Errorf("endpoint rule error, %s", func() string {
														var out strings.Builder
														out.WriteString("Invalid ARN: Kinesis ARNs don't support `")
														out.WriteString(_arnType)
														out.WriteString("` arn types.")
														return out.String()
													}())
												}
											}
											return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid ARN: No ARN type specified")
										}
										return endpoint, fmt.Errorf("endpoint rule error, %s", func() string {
											var out strings.Builder
											out.WriteString("Invalid ARN: The ARN was not for the Kinesis service, found: ")
											out.WriteString(_arn.Service)
											out.WriteString(".")
											return out.String()
										}())
									}
									return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid ARN: Invalid region.")
								}
								return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid ARN: Invalid account id.")
							}
							return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid ARN: Failed to parse ARN.")
						}
					}
				}
			}
		}
	}
	if exprVal := params.ConsumerARN; exprVal != nil {
		_ConsumerARN := *exprVal
		_ = _ConsumerARN
		if !(params.Endpoint != nil) {
			if exprVal := params.Region; exprVal != nil {
				_Region := *exprVal
				_ = _Region
				if exprVal := awsrulesfn.GetPartition(_Region); exprVal != nil {
					_PartitionResult := *exprVal
					_ = _PartitionResult
					if !(_PartitionResult.Name == "aws-iso") {
						if !(_PartitionResult.Name == "aws-iso-b") {
							if exprVal := awsrulesfn.ParseARN(_ConsumerARN); exprVal != nil {
								_arn := *exprVal
								_ = _arn
								if rulesfn.IsValidHostLabel(_arn.AccountId, false) {
									if rulesfn.IsValidHostLabel(_arn.Region, false) {
										if _arn.Service == "kinesis" {
											if exprVal := _arn.ResourceId.Get(0); exprVal != nil {
												_arnType := *exprVal
												_ = _arnType
												if !(_arnType == "") {
													if _arnType == "stream" {
														if _PartitionResult.Name == _arn.Partition {
															if exprVal := params.OperationType; exprVal != nil {
																_OperationType := *exprVal
																_ = _OperationType
																if _UseFIPS == true {
																	if _UseDualStack == true {
																		if _PartitionResult.SupportsFIPS == true {
																			if _PartitionResult.SupportsDualStack == true {
																				uriString := func() string {
																					var out strings.Builder
																					out.WriteString("https://")
																					out.WriteString(_arn.AccountId)
																					out.WriteString(".")
																					out.WriteString(_OperationType)
																					out.WriteString("-kinesis-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", "DualStack is enabled, but this partition does not support DualStack.")
																		}
																		return endpoint, fmt.Errorf("endpoint rule error, %s", "FIPS is enabled, but this partition does not support FIPS.")
																	}
																}
																if _UseFIPS == true {
																	if _PartitionResult.SupportsFIPS == true {
																		uriString := func() string {
																			var out strings.Builder
																			out.WriteString("https://")
																			out.WriteString(_arn.AccountId)
																			out.WriteString(".")
																			out.WriteString(_OperationType)
																			out.WriteString("-kinesis-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 {
																		uriString := func() string {
																			var out strings.Builder
																			out.WriteString("https://")
																			out.WriteString(_arn.AccountId)
																			out.WriteString(".")
																			out.WriteString(_OperationType)
																			out.WriteString("-kinesis.")
																			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")
																}
																uriString := func() string {
																	var out strings.Builder
																	out.WriteString("https://")
																	out.WriteString(_arn.AccountId)
																	out.WriteString(".")
																	out.WriteString(_OperationType)
																	out.WriteString("-kinesis.")
																	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", "Operation Type is not set. Please contact service team for resolution.")
														}
														return endpoint, fmt.Errorf("endpoint rule error, %s", func() string {
															var out strings.Builder
															out.WriteString("Partition: ")
															out.WriteString(_arn.Partition)
															out.WriteString(" from ARN doesn't match with partition name: ")
															out.WriteString(_PartitionResult.Name)
															out.WriteString(".")
															return out.String()
														}())
													}
													return endpoint, fmt.Errorf("endpoint rule error, %s", func() string {
														var out strings.Builder
														out.WriteString("Invalid ARN: Kinesis ARNs don't support `")
														out.WriteString(_arnType)
														out.WriteString("` arn types.")
														return out.String()
													}())
												}
											}
											return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid ARN: No ARN type specified")
										}
										return endpoint, fmt.Errorf("endpoint rule error, %s", func() string {
											var out strings.Builder
											out.WriteString("Invalid ARN: The ARN was not for the Kinesis service, found: ")
											out.WriteString(_arn.Service)
											out.WriteString(".")
											return out.String()
										}())
									}
									return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid ARN: Invalid region.")
								}
								return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid ARN: Invalid account id.")
							}
							return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid ARN: Failed to parse ARN.")
						}
					}
				}
			}
		}
	}
	if exprVal := params.ResourceARN; exprVal != nil {
		_ResourceARN := *exprVal
		_ = _ResourceARN
		if !(params.Endpoint != nil) {
			if exprVal := params.Region; exprVal != nil {
				_Region := *exprVal
				_ = _Region
				if exprVal := awsrulesfn.GetPartition(_Region); exprVal != nil {
					_PartitionResult := *exprVal
					_ = _PartitionResult
					if !(_PartitionResult.Name == "aws-iso") {
						if !(_PartitionResult.Name == "aws-iso-b") {
							if exprVal := awsrulesfn.ParseARN(_ResourceARN); exprVal != nil {
								_arn := *exprVal
								_ = _arn
								if rulesfn.IsValidHostLabel(_arn.AccountId, false) {
									if rulesfn.IsValidHostLabel(_arn.Region, false) {
										if _arn.Service == "kinesis" {
											if exprVal := _arn.ResourceId.Get(0); exprVal != nil {
												_arnType := *exprVal
												_ = _arnType
												if !(_arnType == "") {
													if _arnType == "stream" {
														if _PartitionResult.Name == _arn.Partition {
															if exprVal := params.OperationType; exprVal != nil {
																_OperationType := *exprVal
																_ = _OperationType
																if _UseFIPS == true {
																	if _UseDualStack == true {
																		if _PartitionResult.SupportsFIPS == true {
																			if _PartitionResult.SupportsDualStack == true {
																				uriString := func() string {
																					var out strings.Builder
																					out.WriteString("https://")
																					out.WriteString(_arn.AccountId)
																					out.WriteString(".")
																					out.WriteString(_OperationType)
																					out.WriteString("-kinesis-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", "DualStack is enabled, but this partition does not support DualStack.")
																		}
																		return endpoint, fmt.Errorf("endpoint rule error, %s", "FIPS is enabled, but this partition does not support FIPS.")
																	}
																}
																if _UseFIPS == true {
																	if _PartitionResult.SupportsFIPS == true {
																		uriString := func() string {
																			var out strings.Builder
																			out.WriteString("https://")
																			out.WriteString(_arn.AccountId)
																			out.WriteString(".")
																			out.WriteString(_OperationType)
																			out.WriteString("-kinesis-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 {
																		uriString := func() string {
																			var out strings.Builder
																			out.WriteString("https://")
																			out.WriteString(_arn.AccountId)
																			out.WriteString(".")
																			out.WriteString(_OperationType)
																			out.WriteString("-kinesis.")
																			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")
																}
																uriString := func() string {
																	var out strings.Builder
																	out.WriteString("https://")
																	out.WriteString(_arn.AccountId)
																	out.WriteString(".")
																	out.WriteString(_OperationType)
																	out.WriteString("-kinesis.")
																	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", "Operation Type is not set. Please contact service team for resolution.")
														}
														return endpoint, fmt.Errorf("endpoint rule error, %s", func() string {
															var out strings.Builder
															out.WriteString("Partition: ")
															out.WriteString(_arn.Partition)
															out.WriteString(" from ARN doesn't match with partition name: ")
															out.WriteString(_PartitionResult.Name)
															out.WriteString(".")
															return out.String()
														}())
													}
													return endpoint, fmt.Errorf("endpoint rule error, %s", func() string {
														var out strings.Builder
														out.WriteString("Invalid ARN: Kinesis ARNs don't support `")
														out.WriteString(_arnType)
														out.WriteString("` arn types.")
														return out.String()
													}())
												}
											}
											return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid ARN: No ARN type specified")
										}
										return endpoint, fmt.Errorf("endpoint rule error, %s", func() string {
											var out strings.Builder
											out.WriteString("Invalid ARN: The ARN was not for the Kinesis service, found: ")
											out.WriteString(_arn.Service)
											out.WriteString(".")
											return out.String()
										}())
									}
									return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid ARN: Invalid region.")
								}
								return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid ARN: Invalid account id.")
							}
							return endpoint, fmt.Errorf("endpoint rule error, %s", "Invalid ARN: Failed to parse ARN.")
						}
					}
				}
			}
		}
	}
	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 _UseFIPS == true {
				if _UseDualStack == true {
					if true == _PartitionResult.SupportsFIPS {
						if true == _PartitionResult.SupportsDualStack {
							uriString := func() string {
								var out strings.Builder
								out.WriteString("https://kinesis-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" {
						uriString := func() string {
							var out strings.Builder
							out.WriteString("https://kinesis.")
							out.WriteString(_Region)
							out.WriteString(".amazonaws.com")
							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
					}
					uriString := func() string {
						var out strings.Builder
						out.WriteString("https://kinesis-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 true == _PartitionResult.SupportsDualStack {
					uriString := func() string {
						var out strings.Builder
						out.WriteString("https://kinesis.")
						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")
			}
			uriString := func() string {
				var out strings.Builder
				out.WriteString("https://kinesis.")
				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")
}