903 lines
27 KiB
Go
903 lines
27 KiB
Go
// Code generated by smithy-go-codegen DO NOT EDIT.
|
|
|
|
package signin
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"github.com/aws/aws-sdk-go-v2/aws"
|
|
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
|
|
internalConfig "github.com/aws/aws-sdk-go-v2/internal/configsources"
|
|
"github.com/aws/aws-sdk-go-v2/internal/endpoints"
|
|
"github.com/aws/aws-sdk-go-v2/internal/endpoints/awsrulesfn"
|
|
internalendpoints "github.com/aws/aws-sdk-go-v2/service/signin/internal/endpoints"
|
|
smithy "github.com/aws/smithy-go"
|
|
smithyauth "github.com/aws/smithy-go/auth"
|
|
smithyendpoints "github.com/aws/smithy-go/endpoints"
|
|
"github.com/aws/smithy-go/endpoints/private/bdd"
|
|
"github.com/aws/smithy-go/endpoints/private/rulesfn"
|
|
"github.com/aws/smithy-go/middleware"
|
|
"github.com/aws/smithy-go/ptr"
|
|
"github.com/aws/smithy-go/tracing"
|
|
smithyhttp "github.com/aws/smithy-go/transport/http"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"strings"
|
|
)
|
|
|
|
// EndpointResolverOptions is the service endpoint resolver options
|
|
type EndpointResolverOptions = internalendpoints.Options
|
|
|
|
// EndpointResolver interface for resolving service endpoints.
|
|
type EndpointResolver interface {
|
|
ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
|
|
}
|
|
|
|
var _ EndpointResolver = &internalendpoints.Resolver{}
|
|
|
|
// NewDefaultEndpointResolver constructs a new service endpoint resolver
|
|
func NewDefaultEndpointResolver() *internalendpoints.Resolver {
|
|
return internalendpoints.New()
|
|
}
|
|
|
|
// EndpointResolverFunc is a helper utility that wraps a function so it satisfies
|
|
// the EndpointResolver interface. This is useful when you want to add additional
|
|
// endpoint resolving logic, or stub out specific endpoints with custom values.
|
|
type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)
|
|
|
|
func (fn EndpointResolverFunc) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) {
|
|
return fn(region, options)
|
|
}
|
|
|
|
// EndpointResolverFromURL returns an EndpointResolver configured using the
|
|
// provided endpoint url. By default, the resolved endpoint resolver uses the
|
|
// client region as signing region, and the endpoint source is set to
|
|
// EndpointSourceCustom.You can provide functional options to configure endpoint
|
|
// values for the resolved endpoint.
|
|
func EndpointResolverFromURL(url string, optFns ...func(*aws.Endpoint)) EndpointResolver {
|
|
e := aws.Endpoint{URL: url, Source: aws.EndpointSourceCustom}
|
|
for _, fn := range optFns {
|
|
fn(&e)
|
|
}
|
|
|
|
return EndpointResolverFunc(
|
|
func(region string, options EndpointResolverOptions) (aws.Endpoint, error) {
|
|
if len(e.SigningRegion) == 0 {
|
|
e.SigningRegion = region
|
|
}
|
|
return e, nil
|
|
},
|
|
)
|
|
}
|
|
|
|
type ResolveEndpoint struct {
|
|
Resolver EndpointResolver
|
|
Options EndpointResolverOptions
|
|
}
|
|
|
|
func (*ResolveEndpoint) ID() string {
|
|
return "ResolveEndpoint"
|
|
}
|
|
|
|
func (m *ResolveEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
|
|
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
if !awsmiddleware.GetRequiresLegacyEndpoints(ctx) {
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
|
|
req, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
|
|
}
|
|
|
|
if m.Resolver == nil {
|
|
return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil")
|
|
}
|
|
|
|
eo := m.Options
|
|
eo.Logger = middleware.GetLogger(ctx)
|
|
|
|
var endpoint aws.Endpoint
|
|
endpoint, err = m.Resolver.ResolveEndpoint(awsmiddleware.GetRegion(ctx), eo)
|
|
if err != nil {
|
|
nf := (&aws.EndpointNotFoundError{})
|
|
if errors.As(err, &nf) {
|
|
ctx = awsmiddleware.SetRequiresLegacyEndpoints(ctx, false)
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err)
|
|
}
|
|
|
|
req.URL, err = url.Parse(endpoint.URL)
|
|
if err != nil {
|
|
return out, metadata, fmt.Errorf("failed to parse endpoint URL: %w", err)
|
|
}
|
|
|
|
if len(awsmiddleware.GetSigningName(ctx)) == 0 {
|
|
signingName := endpoint.SigningName
|
|
if len(signingName) == 0 {
|
|
signingName = "signin"
|
|
}
|
|
ctx = awsmiddleware.SetSigningName(ctx, signingName)
|
|
}
|
|
ctx = awsmiddleware.SetEndpointSource(ctx, endpoint.Source)
|
|
ctx = smithyhttp.SetHostnameImmutable(ctx, endpoint.HostnameImmutable)
|
|
ctx = awsmiddleware.SetSigningRegion(ctx, endpoint.SigningRegion)
|
|
ctx = awsmiddleware.SetPartitionID(ctx, endpoint.PartitionID)
|
|
return next.HandleSerialize(ctx, in)
|
|
}
|
|
func addResolveEndpointMiddleware(stack *middleware.Stack, o Options) error {
|
|
return stack.Serialize.Insert(&ResolveEndpoint{
|
|
Resolver: o.EndpointResolver,
|
|
Options: o.EndpointOptions,
|
|
}, "OperationSerializer", middleware.Before)
|
|
}
|
|
|
|
func removeResolveEndpointMiddleware(stack *middleware.Stack) error {
|
|
_, err := stack.Serialize.Remove((&ResolveEndpoint{}).ID())
|
|
return err
|
|
}
|
|
|
|
type wrappedEndpointResolver struct {
|
|
awsResolver aws.EndpointResolverWithOptions
|
|
}
|
|
|
|
func (w *wrappedEndpointResolver) ResolveEndpoint(region string, options EndpointResolverOptions) (endpoint aws.Endpoint, err error) {
|
|
return w.awsResolver.ResolveEndpoint(ServiceID, region, options)
|
|
}
|
|
|
|
type awsEndpointResolverAdaptor func(service, region string) (aws.Endpoint, error)
|
|
|
|
func (a awsEndpointResolverAdaptor) ResolveEndpoint(service, region string, options ...interface{}) (aws.Endpoint, error) {
|
|
return a(service, region)
|
|
}
|
|
|
|
var _ aws.EndpointResolverWithOptions = awsEndpointResolverAdaptor(nil)
|
|
|
|
// withEndpointResolver returns an aws.EndpointResolverWithOptions that first delegates endpoint resolution to the awsResolver.
|
|
// If awsResolver returns aws.EndpointNotFoundError error, the v1 resolver middleware will swallow the error,
|
|
// and set an appropriate context flag such that fallback will occur when EndpointResolverV2 is invoked
|
|
// via its middleware.
|
|
//
|
|
// If another error (besides aws.EndpointNotFoundError) is returned, then that error will be propagated.
|
|
func withEndpointResolver(awsResolver aws.EndpointResolver, awsResolverWithOptions aws.EndpointResolverWithOptions) EndpointResolver {
|
|
var resolver aws.EndpointResolverWithOptions
|
|
|
|
if awsResolverWithOptions != nil {
|
|
resolver = awsResolverWithOptions
|
|
} else if awsResolver != nil {
|
|
resolver = awsEndpointResolverAdaptor(awsResolver.ResolveEndpoint)
|
|
}
|
|
|
|
return &wrappedEndpointResolver{
|
|
awsResolver: resolver,
|
|
}
|
|
}
|
|
|
|
func finalizeClientEndpointResolverOptions(options *Options) {
|
|
options.EndpointOptions.LogDeprecated = options.ClientLogMode.IsDeprecatedUsage()
|
|
|
|
if len(options.EndpointOptions.ResolvedRegion) == 0 {
|
|
const fipsInfix = "-fips-"
|
|
const fipsPrefix = "fips-"
|
|
const fipsSuffix = "-fips"
|
|
|
|
if strings.Contains(options.Region, fipsInfix) ||
|
|
strings.Contains(options.Region, fipsPrefix) ||
|
|
strings.Contains(options.Region, fipsSuffix) {
|
|
options.EndpointOptions.ResolvedRegion = strings.ReplaceAll(strings.ReplaceAll(strings.ReplaceAll(
|
|
options.Region, fipsInfix, "-"), fipsPrefix, ""), fipsSuffix, "")
|
|
options.EndpointOptions.UseFIPSEndpoint = aws.FIPSEndpointStateEnabled
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
func resolveEndpointResolverV2(options *Options) {
|
|
if options.EndpointResolverV2 == nil {
|
|
options.EndpointResolverV2 = NewDefaultEndpointResolverV2()
|
|
}
|
|
}
|
|
|
|
func resolveBaseEndpoint(cfg aws.Config, o *Options) {
|
|
if cfg.BaseEndpoint != nil {
|
|
o.BaseEndpoint = cfg.BaseEndpoint
|
|
}
|
|
|
|
_, g := os.LookupEnv("AWS_ENDPOINT_URL")
|
|
_, s := os.LookupEnv("AWS_ENDPOINT_URL_SIGNIN")
|
|
|
|
if g && !s {
|
|
return
|
|
}
|
|
|
|
value, found, err := internalConfig.ResolveServiceBaseEndpoint(context.Background(), "Signin", cfg.ConfigSources)
|
|
if found && err == nil {
|
|
o.BaseEndpoint = &value
|
|
}
|
|
}
|
|
|
|
func bindRegion(region string) (*string, error) {
|
|
if region == "" {
|
|
return nil, nil
|
|
}
|
|
if !rulesfn.IsValidHostLabel(region, true) {
|
|
return nil, fmt.Errorf("invalid input region %s", region)
|
|
}
|
|
|
|
return aws.String(endpoints.MapFIPSRegion(region)), nil
|
|
}
|
|
|
|
var _ = rulesfn.StringSlice(nil)
|
|
|
|
// EndpointParameters provides the parameters that influence how endpoints are
|
|
// resolved.
|
|
type EndpointParameters struct {
|
|
// When true, use the dual-stack endpoint. If the configured endpoint does not
|
|
// support dual-stack, dispatching the request MAY return an error.
|
|
//
|
|
// Defaults to
|
|
// false if no value is provided.
|
|
//
|
|
// AWS::UseDualStack
|
|
UseDualStack *bool
|
|
|
|
// When true, send this request to the FIPS-compliant regional endpoint. If the
|
|
// configured endpoint does not have a FIPS compliant endpoint, dispatching the
|
|
// request will return an error.
|
|
//
|
|
// Defaults to false if no value is
|
|
// provided.
|
|
//
|
|
// AWS::UseFIPS
|
|
UseFIPS *bool
|
|
|
|
// Override the endpoint used to send this request
|
|
//
|
|
// Parameter is
|
|
// required.
|
|
//
|
|
// SDK::Endpoint
|
|
Endpoint *string
|
|
|
|
// The AWS region used to dispatch the request.
|
|
//
|
|
// Parameter is
|
|
// required.
|
|
//
|
|
// AWS::Region
|
|
Region *string
|
|
|
|
// Indicates if the operation targets the control plane endpoint
|
|
//
|
|
// Parameter is
|
|
// required.
|
|
IsControlPlane *bool
|
|
|
|
// Indicates if the operation targets the OAuth token endpoint
|
|
//
|
|
// Parameter is
|
|
// required.
|
|
IsOAuthEndpoint *bool
|
|
}
|
|
|
|
// ValidateRequired validates required parameters are set.
|
|
func (p EndpointParameters) ValidateRequired() error {
|
|
if p.UseDualStack == nil {
|
|
return fmt.Errorf("parameter UseDualStack is required")
|
|
}
|
|
|
|
if p.UseFIPS == nil {
|
|
return fmt.Errorf("parameter UseFIPS is required")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// WithDefaults returns a shallow copy of EndpointParameterswith default values
|
|
// applied to members where applicable.
|
|
func (p EndpointParameters) WithDefaults() EndpointParameters {
|
|
if p.UseDualStack == nil {
|
|
p.UseDualStack = ptr.Bool(false)
|
|
}
|
|
|
|
if p.UseFIPS == nil {
|
|
p.UseFIPS = ptr.Bool(false)
|
|
}
|
|
return p
|
|
}
|
|
|
|
const bddRoot int32 = 2
|
|
|
|
var bddNodes = [120]int32{
|
|
-1, 1, -1, 0, 6, 3, 2, 36, 4, 4, 5, 100000027, 6, 100000004, 100000027, 1, 29, 7, 2, 36, 8, 3, 9, 31, 4, 22, 10, 5, 19, 11, 7, 21, 12, 8, 100000007, 13, 10, 100000008, 14, 12, 100000009, 15, 13, 100000010, 16, 14, 100000011, 17, 15, 100000012, 18, 16, 100000013, 100000016, 6, 100000005, 20, 7, 21, 100000006, 17, 100000024, 100000025, 6, 100000004, 23, 7, 27, 24, 9, 100000014, 25, 10, 100000015, 26, 11, 100000022, 100000023, 11, 28, 100000021, 17, 100000020, 100000021, 2, 35, 30, 3, 39, 31, 4, 32, 100000027, 6, 100000004, 33, 7, 100000027, 34, 9, 100000014, 100000027, 3, 39, 36, 4, 38, 37, 7, 100000018, 100000019, 6, 100000004, 100000017, 5, 100000001, 40, 8, 100000002, 100000003}
|
|
|
|
type conditionContext struct {
|
|
PartitionResult *awsrulesfn.PartitionConfig
|
|
}
|
|
|
|
func evalCondition(idx int, params *EndpointParameters, c *conditionContext) bool {
|
|
switch idx {
|
|
case 0:
|
|
return params.Region != nil
|
|
case 1:
|
|
return func() bool {
|
|
if v := params.IsControlPlane; v != nil {
|
|
return *v
|
|
}
|
|
return false
|
|
}() == true
|
|
case 2:
|
|
return params.Endpoint != nil
|
|
case 3:
|
|
if v := awsrulesfn.GetPartition(*params.Region); v != nil {
|
|
c.PartitionResult = v
|
|
return true
|
|
}
|
|
return false
|
|
case 4:
|
|
return *params.UseFIPS == true
|
|
case 5:
|
|
return c.PartitionResult.Name == "aws"
|
|
case 6:
|
|
return func() bool {
|
|
if v := params.IsOAuthEndpoint; v != nil {
|
|
return *v
|
|
}
|
|
return false
|
|
}() == true
|
|
case 7:
|
|
return *params.UseDualStack == true
|
|
case 8:
|
|
return c.PartitionResult.Name == "aws-cn"
|
|
case 9:
|
|
return *params.Region == "us-gov-west-1"
|
|
case 10:
|
|
return c.PartitionResult.Name == "aws-us-gov"
|
|
case 11:
|
|
return c.PartitionResult.SupportsFIPS == true
|
|
case 12:
|
|
return c.PartitionResult.Name == "aws-iso"
|
|
case 13:
|
|
return c.PartitionResult.Name == "aws-iso-b"
|
|
case 14:
|
|
return c.PartitionResult.Name == "aws-iso-f"
|
|
case 15:
|
|
return c.PartitionResult.Name == "aws-iso-e"
|
|
case 16:
|
|
return c.PartitionResult.Name == "aws-eusc"
|
|
case 17:
|
|
return c.PartitionResult.SupportsDualStack == true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func resolveResult(idx int32, params *EndpointParameters, c *conditionContext) (smithyendpoints.Endpoint, error) {
|
|
switch idx {
|
|
case 0:
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint resolution failed: no matching rule")
|
|
case 1:
|
|
uriString := func() string {
|
|
var out strings.Builder
|
|
out.WriteString("https://signin.")
|
|
out.WriteString(*params.Region)
|
|
out.WriteString(".api.aws")
|
|
return out.String()
|
|
}()
|
|
uri, err := url.Parse(uriString)
|
|
if err != nil {
|
|
return smithyendpoints.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: "sigv4",
|
|
SignerProperties: func() smithy.Properties {
|
|
var sp smithy.Properties
|
|
smithyhttp.SetSigV4SigningName(&sp, "signin")
|
|
smithyhttp.SetSigV4ASigningName(&sp, "signin")
|
|
|
|
smithyhttp.SetSigV4SigningRegion(&sp, *params.Region)
|
|
return sp
|
|
}(),
|
|
},
|
|
})
|
|
return out
|
|
}(),
|
|
}, nil
|
|
case 2:
|
|
uriString := func() string {
|
|
var out strings.Builder
|
|
out.WriteString("https://signin.")
|
|
out.WriteString(*params.Region)
|
|
out.WriteString(".api.amazonwebservices.com.cn")
|
|
return out.String()
|
|
}()
|
|
uri, err := url.Parse(uriString)
|
|
if err != nil {
|
|
return smithyendpoints.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: "sigv4",
|
|
SignerProperties: func() smithy.Properties {
|
|
var sp smithy.Properties
|
|
smithyhttp.SetSigV4SigningName(&sp, "signin")
|
|
smithyhttp.SetSigV4ASigningName(&sp, "signin")
|
|
|
|
smithyhttp.SetSigV4SigningRegion(&sp, *params.Region)
|
|
return sp
|
|
}(),
|
|
},
|
|
})
|
|
return out
|
|
}(),
|
|
}, nil
|
|
case 3:
|
|
uriString := func() string {
|
|
var out strings.Builder
|
|
out.WriteString("https://signin.")
|
|
out.WriteString(*params.Region)
|
|
out.WriteString(".")
|
|
out.WriteString(c.PartitionResult.DualStackDnsSuffix)
|
|
return out.String()
|
|
}()
|
|
uri, err := url.Parse(uriString)
|
|
if err != nil {
|
|
return smithyendpoints.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: "sigv4",
|
|
SignerProperties: func() smithy.Properties {
|
|
var sp smithy.Properties
|
|
smithyhttp.SetSigV4SigningName(&sp, "signin")
|
|
smithyhttp.SetSigV4ASigningName(&sp, "signin")
|
|
|
|
smithyhttp.SetSigV4SigningRegion(&sp, *params.Region)
|
|
return sp
|
|
}(),
|
|
},
|
|
})
|
|
return out
|
|
}(),
|
|
}, nil
|
|
case 4:
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "FIPS endpoints are not supported for OAuth operations. Disable FIPS or use a non-OAuth operation.")
|
|
case 5:
|
|
uriString := func() string {
|
|
var out strings.Builder
|
|
out.WriteString("https://")
|
|
out.WriteString(*params.Region)
|
|
out.WriteString(".oauth.signin.aws")
|
|
return out.String()
|
|
}()
|
|
uri, err := url.Parse(uriString)
|
|
if err != nil {
|
|
return smithyendpoints.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: "sigv4",
|
|
SignerProperties: func() smithy.Properties {
|
|
var sp smithy.Properties
|
|
smithyhttp.SetSigV4SigningName(&sp, "signin")
|
|
smithyhttp.SetSigV4ASigningName(&sp, "signin")
|
|
|
|
smithyhttp.SetSigV4SigningRegion(&sp, *params.Region)
|
|
return sp
|
|
}(),
|
|
},
|
|
})
|
|
return out
|
|
}(),
|
|
}, nil
|
|
case 6:
|
|
uriString := func() string {
|
|
var out strings.Builder
|
|
out.WriteString("https://")
|
|
out.WriteString(*params.Region)
|
|
out.WriteString(".signin.aws.amazon.com")
|
|
return out.String()
|
|
}()
|
|
uri, err := url.Parse(uriString)
|
|
if err != nil {
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
|
|
}
|
|
return smithyendpoints.Endpoint{
|
|
URI: *uri,
|
|
Headers: http.Header{},
|
|
}, nil
|
|
case 7:
|
|
uriString := func() string {
|
|
var out strings.Builder
|
|
out.WriteString("https://")
|
|
out.WriteString(*params.Region)
|
|
out.WriteString(".signin.amazonaws.cn")
|
|
return out.String()
|
|
}()
|
|
uri, err := url.Parse(uriString)
|
|
if err != nil {
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
|
|
}
|
|
return smithyendpoints.Endpoint{
|
|
URI: *uri,
|
|
Headers: http.Header{},
|
|
}, nil
|
|
case 8:
|
|
uriString := func() string {
|
|
var out strings.Builder
|
|
out.WriteString("https://")
|
|
out.WriteString(*params.Region)
|
|
out.WriteString(".signin.amazonaws-us-gov.com")
|
|
return out.String()
|
|
}()
|
|
uri, err := url.Parse(uriString)
|
|
if err != nil {
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
|
|
}
|
|
return smithyendpoints.Endpoint{
|
|
URI: *uri,
|
|
Headers: http.Header{},
|
|
}, nil
|
|
case 9:
|
|
uriString := func() string {
|
|
var out strings.Builder
|
|
out.WriteString("https://")
|
|
out.WriteString(*params.Region)
|
|
out.WriteString(".signin.c2shome.ic.gov")
|
|
return out.String()
|
|
}()
|
|
uri, err := url.Parse(uriString)
|
|
if err != nil {
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
|
|
}
|
|
return smithyendpoints.Endpoint{
|
|
URI: *uri,
|
|
Headers: http.Header{},
|
|
}, nil
|
|
case 10:
|
|
uriString := func() string {
|
|
var out strings.Builder
|
|
out.WriteString("https://")
|
|
out.WriteString(*params.Region)
|
|
out.WriteString(".signin.sc2shome.sgov.gov")
|
|
return out.String()
|
|
}()
|
|
uri, err := url.Parse(uriString)
|
|
if err != nil {
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
|
|
}
|
|
return smithyendpoints.Endpoint{
|
|
URI: *uri,
|
|
Headers: http.Header{},
|
|
}, nil
|
|
case 11:
|
|
uriString := func() string {
|
|
var out strings.Builder
|
|
out.WriteString("https://")
|
|
out.WriteString(*params.Region)
|
|
out.WriteString(".signin.csphome.hci.ic.gov")
|
|
return out.String()
|
|
}()
|
|
uri, err := url.Parse(uriString)
|
|
if err != nil {
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
|
|
}
|
|
return smithyendpoints.Endpoint{
|
|
URI: *uri,
|
|
Headers: http.Header{},
|
|
}, nil
|
|
case 12:
|
|
uriString := func() string {
|
|
var out strings.Builder
|
|
out.WriteString("https://")
|
|
out.WriteString(*params.Region)
|
|
out.WriteString(".signin.csphome.adc-e.uk")
|
|
return out.String()
|
|
}()
|
|
uri, err := url.Parse(uriString)
|
|
if err != nil {
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
|
|
}
|
|
return smithyendpoints.Endpoint{
|
|
URI: *uri,
|
|
Headers: http.Header{},
|
|
}, nil
|
|
case 13:
|
|
uriString := func() string {
|
|
var out strings.Builder
|
|
out.WriteString("https://")
|
|
out.WriteString(*params.Region)
|
|
out.WriteString(".signin.amazonaws-eusc.eu")
|
|
return out.String()
|
|
}()
|
|
uri, err := url.Parse(uriString)
|
|
if err != nil {
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
|
|
}
|
|
return smithyendpoints.Endpoint{
|
|
URI: *uri,
|
|
Headers: http.Header{},
|
|
}, nil
|
|
case 14:
|
|
uriString := "https://signin-fips.amazonaws-us-gov.com"
|
|
uri, err := url.Parse(uriString)
|
|
if err != nil {
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
|
|
}
|
|
return smithyendpoints.Endpoint{
|
|
URI: *uri,
|
|
Headers: http.Header{},
|
|
}, nil
|
|
case 15:
|
|
uriString := func() string {
|
|
var out strings.Builder
|
|
out.WriteString("https://")
|
|
out.WriteString(*params.Region)
|
|
out.WriteString(".signin-fips.amazonaws-us-gov.com")
|
|
return out.String()
|
|
}()
|
|
uri, err := url.Parse(uriString)
|
|
if err != nil {
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
|
|
}
|
|
return smithyendpoints.Endpoint{
|
|
URI: *uri,
|
|
Headers: http.Header{},
|
|
}, nil
|
|
case 16:
|
|
uriString := func() string {
|
|
var out strings.Builder
|
|
out.WriteString("https://")
|
|
out.WriteString(*params.Region)
|
|
out.WriteString(".signin.")
|
|
out.WriteString(c.PartitionResult.DnsSuffix)
|
|
return out.String()
|
|
}()
|
|
uri, err := url.Parse(uriString)
|
|
if err != nil {
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
|
|
}
|
|
return smithyendpoints.Endpoint{
|
|
URI: *uri,
|
|
Headers: http.Header{},
|
|
}, nil
|
|
case 17:
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: FIPS and custom endpoint are not supported")
|
|
case 18:
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: Dualstack and custom endpoint are not supported")
|
|
case 19:
|
|
uriString := *params.Endpoint
|
|
uri, err := url.Parse(uriString)
|
|
if err != nil {
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
|
|
}
|
|
return smithyendpoints.Endpoint{
|
|
URI: *uri,
|
|
Headers: http.Header{},
|
|
}, nil
|
|
case 20:
|
|
uriString := func() string {
|
|
var out strings.Builder
|
|
out.WriteString("https://signin-fips.")
|
|
out.WriteString(*params.Region)
|
|
out.WriteString(".")
|
|
out.WriteString(c.PartitionResult.DualStackDnsSuffix)
|
|
return out.String()
|
|
}()
|
|
uri, err := url.Parse(uriString)
|
|
if err != nil {
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
|
|
}
|
|
return smithyendpoints.Endpoint{
|
|
URI: *uri,
|
|
Headers: http.Header{},
|
|
}, nil
|
|
case 21:
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "FIPS and DualStack are enabled, but this partition does not support one or both")
|
|
case 22:
|
|
uriString := func() string {
|
|
var out strings.Builder
|
|
out.WriteString("https://signin-fips.")
|
|
out.WriteString(*params.Region)
|
|
out.WriteString(".")
|
|
out.WriteString(c.PartitionResult.DnsSuffix)
|
|
return out.String()
|
|
}()
|
|
uri, err := url.Parse(uriString)
|
|
if err != nil {
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
|
|
}
|
|
return smithyendpoints.Endpoint{
|
|
URI: *uri,
|
|
Headers: http.Header{},
|
|
}, nil
|
|
case 23:
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "FIPS is enabled but this partition does not support FIPS")
|
|
case 24:
|
|
uriString := func() string {
|
|
var out strings.Builder
|
|
out.WriteString("https://signin.")
|
|
out.WriteString(*params.Region)
|
|
out.WriteString(".")
|
|
out.WriteString(c.PartitionResult.DualStackDnsSuffix)
|
|
return out.String()
|
|
}()
|
|
uri, err := url.Parse(uriString)
|
|
if err != nil {
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
|
|
}
|
|
return smithyendpoints.Endpoint{
|
|
URI: *uri,
|
|
Headers: http.Header{},
|
|
}, nil
|
|
case 25:
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "DualStack is enabled but this partition does not support DualStack")
|
|
case 26:
|
|
uriString := func() string {
|
|
var out strings.Builder
|
|
out.WriteString("https://signin.")
|
|
out.WriteString(*params.Region)
|
|
out.WriteString(".")
|
|
out.WriteString(c.PartitionResult.DnsSuffix)
|
|
return out.String()
|
|
}()
|
|
uri, err := url.Parse(uriString)
|
|
if err != nil {
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
|
|
}
|
|
return smithyendpoints.Endpoint{
|
|
URI: *uri,
|
|
Headers: http.Header{},
|
|
}, nil
|
|
case 27:
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: Missing Region")
|
|
}
|
|
return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, invalid result index: %d", idx)
|
|
}
|
|
|
|
// EndpointResolverV2 provides the interface for resolving service endpoints.
|
|
type EndpointResolverV2 interface {
|
|
ResolveEndpoint(ctx context.Context, params EndpointParameters) (
|
|
smithyendpoints.Endpoint, error,
|
|
)
|
|
}
|
|
|
|
// resolver provides the implementation for resolving endpoints.
|
|
type resolver struct{}
|
|
|
|
func NewDefaultEndpointResolverV2() EndpointResolverV2 {
|
|
return &resolver{}
|
|
}
|
|
|
|
// ResolveEndpoint attempts to resolve the endpoint with the provided options,
|
|
// returning the endpoint if found. Otherwise an error is returned.
|
|
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)
|
|
}
|
|
|
|
c := &conditionContext{}
|
|
ref := bdd.Evaluate(bddNodes[:], bddRoot, func(idx int) bool {
|
|
return evalCondition(idx, ¶ms, c)
|
|
})
|
|
return resolveResult(ref, ¶ms, c)
|
|
}
|
|
|
|
type endpointParamsBinder interface {
|
|
bindEndpointParams(*EndpointParameters)
|
|
}
|
|
|
|
func bindEndpointParams(ctx context.Context, input interface{}, options Options) (*EndpointParameters, error) {
|
|
params := &EndpointParameters{}
|
|
|
|
params.UseDualStack = aws.Bool(options.EndpointOptions.UseDualStackEndpoint == aws.DualStackEndpointStateEnabled)
|
|
params.UseFIPS = aws.Bool(options.EndpointOptions.UseFIPSEndpoint == aws.FIPSEndpointStateEnabled)
|
|
params.Endpoint = options.BaseEndpoint
|
|
region, err := bindRegion(options.Region)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
params.Region = region
|
|
|
|
if b, ok := input.(endpointParamsBinder); ok {
|
|
b.bindEndpointParams(params)
|
|
}
|
|
|
|
return params, nil
|
|
}
|
|
|
|
type resolveEndpointV2Middleware struct {
|
|
options Options
|
|
}
|
|
|
|
func (*resolveEndpointV2Middleware) ID() string {
|
|
return "ResolveEndpointV2"
|
|
}
|
|
|
|
func (m *resolveEndpointV2Middleware) HandleFinalize(ctx context.Context, in middleware.FinalizeInput, next middleware.FinalizeHandler) (
|
|
out middleware.FinalizeOutput, metadata middleware.Metadata, err error,
|
|
) {
|
|
_, span := tracing.StartSpan(ctx, "ResolveEndpoint")
|
|
defer span.End()
|
|
|
|
if awsmiddleware.GetRequiresLegacyEndpoints(ctx) {
|
|
return next.HandleFinalize(ctx, in)
|
|
}
|
|
|
|
req, ok := in.Request.(*smithyhttp.Request)
|
|
if !ok {
|
|
return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
|
|
}
|
|
|
|
if m.options.EndpointResolverV2 == nil {
|
|
return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil")
|
|
}
|
|
|
|
params, err := bindEndpointParams(ctx, getOperationInput(ctx), m.options)
|
|
if err != nil {
|
|
return out, metadata, fmt.Errorf("failed to bind endpoint params, %w", err)
|
|
}
|
|
endpt, err := timeOperationMetric(ctx, "client.call.resolve_endpoint_duration",
|
|
func() (smithyendpoints.Endpoint, error) {
|
|
return m.options.EndpointResolverV2.ResolveEndpoint(ctx, *params)
|
|
})
|
|
if err != nil {
|
|
return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err)
|
|
}
|
|
|
|
span.SetProperty("client.call.resolved_endpoint", endpt.URI.String())
|
|
|
|
if endpt.URI.RawPath == "" && req.URL.RawPath != "" {
|
|
endpt.URI.RawPath = endpt.URI.Path
|
|
}
|
|
req.URL.Scheme = endpt.URI.Scheme
|
|
req.URL.Host = endpt.URI.Host
|
|
req.URL.Path = smithyhttp.JoinPath(endpt.URI.Path, req.URL.Path)
|
|
req.URL.RawPath = smithyhttp.JoinPath(endpt.URI.RawPath, req.URL.RawPath)
|
|
for k := range endpt.Headers {
|
|
req.Header.Set(k, endpt.Headers.Get(k))
|
|
}
|
|
|
|
rscheme := getResolvedAuthScheme(ctx)
|
|
if rscheme == nil {
|
|
return out, metadata, fmt.Errorf("no resolved auth scheme")
|
|
}
|
|
|
|
opts, _ := smithyauth.GetAuthOptions(&endpt.Properties)
|
|
for _, o := range opts {
|
|
rscheme.SignerProperties.SetAll(&o.SignerProperties)
|
|
}
|
|
|
|
span.End()
|
|
return next.HandleFinalize(ctx, in)
|
|
}
|