AWS SDK の裏側を見てみよう !

package main

import ( 
    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/dynamodb"
    "github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute"
    
    "fmt"
    "log" 
)

// Create struct to hold info about new item
type Item struct {
    Year   int
    Title  string
    Plot   string
    Rating float64
}

func main() {
    // Initialize a session that the SDK will use to load
    // credentials from the shared credentials file ~/.aws/credentials
    // and region from the shared configuration file ~/.aws/config.
    sess := session.Must(session.NewSessionWithOptions(session.Options{    // ...(A)
        SharedConfigState: session.SharedConfigEnable,
    }))

    // Create DynamoDB client
    svc := dynamodb.New(sess)    // ...(B)
    
    
    tableName := "Movies"
    movieName := "The Big New Movie"
    movieYear := "2015"

    result, err := svc.GetItem(&dynamodb.GetItemInput{    // ...(C)
        TableName: aws.String(tableName),
        Key: map[string]*dynamodb.AttributeValue{
            "Year": {
                N: aws.String(movieYear),
            },
            "Title": {
                S: aws.String(movieName),
            },
        },
    })
    if err != nil {
        log.Fatalf("Got error calling GetItem: %s", err)
    }
    
    if result.Item == nil {
        msg := "Could not find '" + *title + "'"
        return nil, errors.New(msg)
    }
        
    item := Item{}

    err = dynamodbattribute.UnmarshalMap(result.Item, &item)
    if err != nil {
        panic(fmt.Sprintf("Failed to unmarshal Record, %v", err))
    }

    fmt.Println("Found item:")
    fmt.Println("Year:  ", item.Year)
    fmt.Println("Title: ", item.Title)
    fmt.Println("Plot:  ", item.Plot)
    fmt.Println("Rating:", item.Rating)
}

// （A) Session: 基本的な共通設定（25行目）
    sess := session.Must(session.NewSessionWithOptions(session.Options{
        SharedConfigState: session.SharedConfigEnable,
    }))

 // (B) Service client: 単独のAWSサービスを利用するための設定（今回はAmazon DynamoDB）（30行目）
    svc := dynamodb.New(sess)

    // (C) Request: 具体的なAWSサービス利用（今回はAmazon DynamoDBのitem取得）（37行目）
    result, err := svc.GetItem(&dynamodb.GetItemInput{
        TableName: aws.String(tableName),
        Key: map[string]*dynamodb.AttributeValue{
            "Year": {
                N: aws.String(movieYear),
            },
            "Title": {
                S: aws.String(movieName),
            },
        },
    })

    // (A) Session（基本的な共通設定）の作成
    sess := session.Must(session.NewSessionWithOptions(...))
    // (B) Service client（単独のAWSサービスを利用するための設定）の作成
    svc := dynamodb.New(sess)
    // (C) Request送信（具体的なAWSサービス利用操作）の実行（次回へ続く）
    result, err := svc.GetItem(...)

    // (A) Session（基本的な共通設定）の作成
    sess := session.Must(session.NewSessionWithOptions(...))

├── (1) session.Must()    // Session作成時のエラーハンドリングを行う関数
└── (2) session.NewSessionWithOptions()    // Session作成を呼び出す関数
    ├── (3) session.loadSharedEnvConfig()     // 環境変数の読み取りを呼び出す関数
    │   └── session.envConfigLoad()    // 環境変数の読み取りを行う関数
    └── (4) session.newSession()     // 設定統合・Session作成を行う関数
        ├── (5) defaults.Config()     // デフォルト設定を生成する変数
        └── (6) defaults.Handlers()    // デフォルトハンドラーを生成する変数

func Must(sess *Session, err error) *Session {
    if err != nil {
        panic(err)
    }

    return sess
}

func NewSessionWithOptions(opts Options) (*Session, error) {
    var envCfg envConfig
    var err error
    if opts.SharedConfigState == SharedConfigEnable {
        envCfg, err = loadSharedEnvConfig()
        if err != nil {
            return nil, fmt.Errorf("failed to load shared config, %v", err)
        }
    } else {
        envCfg, err = loadEnvConfig()
        if err != nil {
            return nil, fmt.Errorf("failed to load environment config, %v", err)
        }
    }

    if len(opts.Profile) != 0 {
        envCfg.Profile = opts.Profile
    }

    switch opts.SharedConfigState {
    case SharedConfigDisable:
        envCfg.EnableSharedConfig = false
    case SharedConfigEnable:
        envCfg.EnableSharedConfig = true
    }

    return newSession(opts, envCfg, &opts.Config)
}

func loadSharedEnvConfig() (envConfig, error) {
    return envConfigLoad(true)
}

func envConfigLoad(enableSharedConfig bool) (envConfig, error) {
    cfg := envConfig{}

    cfg.EnableSharedConfig = enableSharedConfig

    // Static environment credentials
    var creds credentials.Value
    setFromEnvVal(&creds.AccessKeyID, credAccessEnvKey)
    setFromEnvVal(&creds.SecretAccessKey, credSecretEnvKey)
    setFromEnvVal(&creds.SessionToken, credSessionEnvKey)
    if creds.HasKeys() {
        // Require logical grouping of credentials
        creds.ProviderName = EnvProviderName
        cfg.Creds = creds
    }

    // Role Metadata
    setFromEnvVal(&cfg.RoleARN, roleARNEnvKey)
    setFromEnvVal(&cfg.RoleSessionName, roleSessionNameEnvKey)

    // （〜中略〜）

    setFromEnvVal(&cfg.SharedCredentialsFile, sharedCredsFileEnvKey)
    setFromEnvVal(&cfg.SharedConfigFile, sharedConfigFileEnvKey)

    // （〜中略〜）

    if err := setUseDualStackEndpointFromEnvVal(&cfg.UseDualStackEndpoint, awsUseDualStackEndpoint); err != nil {
        return cfg, err
    }

    if err := setUseFIPSEndpointFromEnvVal(&cfg.UseFIPSEndpoint, awsUseFIPSEndpoint); err != nil {
        return cfg, err
    }

    return cfg, nil
}

    sess := session.Must(session.NewSessionWithOptions(session.Options{
        SharedConfigState: session.SharedConfigEnable,
    }))

func newSession(opts Options, envCfg envConfig, cfgs ...*aws.Config) (*Session, error) {
    cfg := defaults.Config()

    handlers := opts.Handlers
    if handlers.IsEmpty() {
        handlers = defaults.Handlers()
    }

    // Get a merged version of the user provided config to determine if
    // credentials were.
    userCfg := &aws.Config{}
    userCfg.MergeIn(cfgs...)
    cfg.MergeIn(userCfg)

    // Ordered config files will be loaded in with later files overwriting
    // previous config file values.
    var cfgFiles []string
    if opts.SharedConfigFiles != nil {
        cfgFiles = opts.SharedConfigFiles
    } else {
        cfgFiles = []string{envCfg.SharedConfigFile, envCfg.SharedCredentialsFile}
        if !envCfg.EnableSharedConfig {
            // The shared config file (~/.aws/config) is only loaded if instructed
            // to load via the envConfig.EnableSharedConfig (AWS_SDK_LOAD_CONFIG).
            cfgFiles = cfgFiles[1:]
        }
    }

    // Load additional config from file(s)
    sharedCfg, err := loadSharedConfig(envCfg.Profile, cfgFiles, envCfg.EnableSharedConfig)
    if err != nil {
        if len(envCfg.Profile) == 0 && !envCfg.EnableSharedConfig && (envCfg.Creds.HasKeys() || userCfg.Credentials != nil) {
            // Special case where the user has not explicitly specified an AWS_PROFILE,
            // or session.Options.profile, shared config is not enabled, and the
            // environment has credentials, allow the shared config file to fail to
            // load since the user has already provided credentials, and nothing else
            // is required to be read file. Github(aws/aws-sdk-go#2455)
        } else if _, ok := err.(SharedConfigProfileNotExistsError); !ok {
            return nil, err
        }
    }

    if err := mergeConfigSrcs(cfg, userCfg, envCfg, sharedCfg, handlers, opts); err != nil {
        return nil, err
    }

    if err := setTLSOptions(&opts, cfg, envCfg, sharedCfg); err != nil {
        return nil, err
    }

    s := &Session{
        Config:   cfg,
        Handlers: handlers,
        options:  opts,
    }

    initHandlers(s)

    // （〜中略〜）

    return s, nil
}

    s := &Session{
        Config:   cfg,
        Handlers: handlers,
        options:  opts,
    }

func Config() *aws.Config {
    return aws.NewConfig().
        WithCredentials(credentials.AnonymousCredentials).
        WithRegion(os.Getenv("AWS_REGION")).
        WithHTTPClient(http.DefaultClient).
        WithMaxRetries(aws.UseServiceDefaultRetries).
        WithLogger(aws.NewDefaultLogger()).
        WithLogLevel(aws.LogOff).
        WithEndpointResolver(endpoints.DefaultResolver())
}

type Handlers struct {
    Validate         HandlerList
    Build            HandlerList
    BuildStream      HandlerList
    Sign             HandlerList
    Send             HandlerList
    ValidateResponse HandlerList
    Unmarshal        HandlerList
    UnmarshalStream  HandlerList
    UnmarshalMeta    HandlerList
    UnmarshalError   HandlerList
    Retry            HandlerList
    AfterRetry       HandlerList
    CompleteAttempt  HandlerList
    Complete         HandlerList
}

        handlers = defaults.Handlers()

func Handlers() request.Handlers {
    var handlers request.Handlers

    handlers.Validate.PushBackNamed(corehandlers.ValidateEndpointHandler)
    handlers.Validate.AfterEachFn = request.HandlerListStopOnError
    handlers.Build.PushBackNamed(corehandlers.SDKVersionUserAgentHandler)
    handlers.Build.PushBackNamed(corehandlers.AddHostExecEnvUserAgentHander)
    handlers.Build.AfterEachFn = request.HandlerListStopOnError
    handlers.Sign.PushBackNamed(corehandlers.BuildContentLengthHandler)
    handlers.Send.PushBackNamed(corehandlers.ValidateReqSigHandler)
    handlers.Send.PushBackNamed(corehandlers.SendHandler)
    handlers.AfterRetry.PushBackNamed(corehandlers.AfterRetryHandler)
    handlers.ValidateResponse.PushBackNamed(corehandlers.ValidateResponseHandler)

    return handlers
}

    // (B) Service client（単独のAWSサービスを利用するための設定）の作成
    svc := dynamodb.New(sess)

└── (1) dynamodb.New()    // Amazon DynamoDB用のService Client作成を呼び出す関数
    ├── (2) Session.ClientConfig()     // Sessionの設定を取得する関数
    └── (3) dynamodb.newClient()     // Client作成を行う関数

func New(p client.ConfigProvider, cfgs ...*aws.Config) *DynamoDB {
    c := p.ClientConfig(EndpointsID, cfgs...)
    if c.SigningNameDerived || len(c.SigningName) == 0 {
        c.SigningName = EndpointsID
        // No Fallback
    }
    return newClient(*c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName, c.ResolvedRegion)
}

func (s *Session) ClientConfig(service string, cfgs ...*aws.Config) client.Config {
    s = s.Copy(cfgs...)

    resolvedRegion := normalizeRegion(s.Config)

    region := aws.StringValue(s.Config.Region)
    resolved, err := s.resolveEndpoint(service, region, resolvedRegion, s.Config)
    if err != nil {
        s.Handlers.Validate.PushBack(func(r *request.Request) {
            if len(r.ClientInfo.Endpoint) != 0 {
                // Error occurred while resolving endpoint, but the request
                // being invoked has had an endpoint specified after the client
                // was created.
                return
            }
            r.Error = err
        })
    }

    return client.Config{
        Config:             s.Config,
        Handlers:           s.Handlers,
        PartitionID:        resolved.PartitionID,
        Endpoint:           resolved.URL,
        SigningRegion:      resolved.SigningRegion,
        SigningNameDerived: resolved.SigningNameDerived,
        SigningName:        resolved.SigningName,
        ResolvedRegion:     resolvedRegion,
    }
}

// newClient creates, initializes and returns a new service client instance.
func newClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) *DynamoDB {
    svc := &DynamoDB{
        Client: client.New(
            cfg,
            metadata.ClientInfo{
                ServiceName:    ServiceName,
                ServiceID:      ServiceID,
                SigningName:    signingName,
                SigningRegion:  signingRegion,
                PartitionID:    partitionID,
                Endpoint:       endpoint,
                APIVersion:     "2012-08-10",
                ResolvedRegion: resolvedRegion,
                JSONVersion:    "1.0",
                TargetPrefix:   "DynamoDB_20120810",
            },
            handlers,
        ),
    }
    svc.endpointCache = crr.NewEndpointCache(10)

    // Handlers
    svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler)
    svc.Handlers.Build.PushBackNamed(jsonrpc.BuildHandler)
    svc.Handlers.Unmarshal.PushBackNamed(jsonrpc.UnmarshalHandler)
    svc.Handlers.UnmarshalMeta.PushBackNamed(jsonrpc.UnmarshalMetaHandler)
    svc.Handlers.UnmarshalError.PushBackNamed(
        protocol.NewUnmarshalErrorHandler(jsonrpc.NewUnmarshalTypedError(exceptionFromCode)).NamedHandler(),
    )

    // Run custom client initialization if present
    if initClient != nil {
        initClient(svc.Client)
    }

    return svc
}