func BenchmarkPutItem(b *testing.B) {
cfg := aws.Config{
DisableSSL: aws.Bool(true),
Credentials: credentials.NewStaticCredentials("AKID", "SECRET", ""),
}
server := successRespServer([]byte(`{}`))
cfg.Endpoint = aws.String(server.URL)
svc := dynamodb.New(&cfg)
svc.Handlers.Send.Clear()
svc.Handlers.Send.PushBack(func(r *service.Request) {
r.HTTPResponse = &http.Response{
StatusCode: http.StatusOK,
Status: http.StatusText(http.StatusOK),
Body: noopBody,
}
})
b.ResetTimer()
for i := 0; i < b.N; i++ {
av, err := dynamodbattribute.ConvertToMap(dbItem{Key: "MyKey", Data: "MyData"})
if err != nil {
b.Fatal("benchPutItem, expect no ConvertToMap errors", err)
}
params := &dynamodb.PutItemInput{
Item: av,
TableName: aws.String("tablename"),
}
_, err = svc.PutItem(params)
if err != nil {
b.Error("benchPutItem, expect no request errors", err)
}
}
}
func init() {
var ecsconfig aws.Config
if region := os.Getenv("AWS_REGION"); region != "" {
ecsconfig.Region = ®ion
}
if region := os.Getenv("AWS_DEFAULT_REGION"); region != "" {
ecsconfig.Region = ®ion
}
if ecsconfig.Region == nil {
if iid, err := ec2.GetInstanceIdentityDocument(); err == nil {
ecsconfig.Region = &iid.Region
}
}
if envEndpoint := os.Getenv("ECS_BACKEND_HOST"); envEndpoint != "" {
ecsconfig.Endpoint = &envEndpoint
}
ECS = ecs.New(session.New(&ecsconfig))
Cluster = "ecs-functional-tests"
if envCluster := os.Getenv("ECS_CLUSTER"); envCluster != "" {
Cluster = envCluster
}
ECS.CreateCluster(&ecs.CreateClusterInput{
ClusterName: aws.String(Cluster),
})
}
// New initializes a new S3 client connection based on config.
func New() *S3Client {
var (
cfg *aws.Config
)
if config.S3.Endpoint != "" {
cfg = &aws.Config{
Endpoint: aws.String(config.S3.Endpoint),
DisableSSL: aws.Bool(strings.HasPrefix(config.S3.Endpoint, "http://")),
Region: aws.String(config.S3.Region),
S3ForcePathStyle: aws.Bool(config.S3.PathStyle),
}
} else {
cfg = &aws.Config{
Region: aws.String(config.S3.Region),
S3ForcePathStyle: aws.Bool(config.S3.PathStyle),
}
}
if config.S3.Access != "" && config.S3.Secret != "" {
cfg.Credentials = credentials.NewStaticCredentials(
config.S3.Access,
config.S3.Secret,
"",
)
}
return &S3Client{
client: s3.New(
session.New(),
cfg,
),
}
}
func mergeConfigSrcs(cfg, userCfg *aws.Config, envCfg envConfig, sharedCfg sharedConfig, handlers request.Handlers) {
// Merge in user provided configuration
cfg.MergeIn(userCfg)
// Region if not already set by user
if len(aws.StringValue(cfg.Region)) == 0 {
if len(envCfg.Region) > 0 {
cfg.WithRegion(envCfg.Region)
} else if envCfg.EnableSharedConfig && len(sharedCfg.Region) > 0 {
cfg.WithRegion(sharedCfg.Region)
}
}
// Configure credentials if not already set
if cfg.Credentials == credentials.AnonymousCredentials && userCfg.Credentials == nil {
if len(envCfg.Creds.AccessKeyID) > 0 {
cfg.Credentials = credentials.NewStaticCredentialsFromCreds(
envCfg.Creds,
)
} else if envCfg.EnableSharedConfig && len(sharedCfg.AssumeRole.RoleARN) > 0 && sharedCfg.AssumeRoleSource != nil {
cfgCp := *cfg
cfgCp.Credentials = credentials.NewStaticCredentialsFromCreds(
sharedCfg.AssumeRoleSource.Creds,
)
cfg.Credentials = stscreds.NewCredentials(
&Session{
Config: &cfgCp,
Handlers: handlers.Copy(),
},
sharedCfg.AssumeRole.RoleARN,
func(opt *stscreds.AssumeRoleProvider) {
opt.RoleSessionName = sharedCfg.AssumeRole.RoleSessionName
if len(sharedCfg.AssumeRole.ExternalID) > 0 {
opt.ExternalID = aws.String(sharedCfg.AssumeRole.ExternalID)
}
// MFA not supported
},
)
} else if len(sharedCfg.Creds.AccessKeyID) > 0 {
cfg.Credentials = credentials.NewStaticCredentialsFromCreds(
sharedCfg.Creds,
)
} else {
// Fallback to default credentials provider, include mock errors
// for the credential chain so user can identify why credentials
// failed to be retrieved.
cfg.Credentials = credentials.NewCredentials(&credentials.ChainProvider{
VerboseErrors: aws.BoolValue(cfg.CredentialsChainVerboseErrors),
Providers: []credentials.Provider{
&credProviderError{Err: awserr.New("EnvAccessKeyNotFound", "failed to find credentials in the environment.", nil)},
&credProviderError{Err: awserr.New("SharedCredsLoad", fmt.Sprintf("failed to load profile, %s.", envCfg.Profile), nil)},
defaults.RemoteCredProvider(*cfg, handlers),
},
})
}
}
}
func (r *run) initIamClient() *iam.IAM {
var awsconf aws.Config
if r.c.AccessKey != "" && r.c.SecretKey != "" {
awscreds := awscred.NewStaticCredentials(r.c.AccessKey, r.c.SecretKey, "")
awsconf.Credentials = awscreds
}
return iam.New(session.New(), &awsconf)
}
func (factory *ecrFactory) newClient(region, endpointOverride string) ECRSDK {
var ecrConfig aws.Config
ecrConfig.Region = ®ion
ecrConfig.HTTPClient = factory.httpClient
if endpointOverride != "" {
ecrConfig.Endpoint = &endpointOverride
}
return ecrapi.New(&ecrConfig)
}
func getService(debug bool) *route53.Route53 {
config := aws.Config{}
// ensures throttled requests are retried
config.MaxRetries = aws.Int(100)
if debug {
config.LogLevel = aws.LogLevel(aws.LogDebug)
}
return route53.New(&config)
}
// newSubmitStateChangeClient returns a client intended to be used for
// Submit*StateChange APIs which has the behavior of retrying the call on
// retriable errors for an extended period of time (roughly 24 hours).
func newSubmitStateChangeClient(awsConfig *aws.Config) *ecs.ECS {
sscConfig := awsConfig.Copy()
sscConfig.MaxRetries = submitStateChangeMaxDelayRetries
client := ecs.New(&sscConfig)
client.Handlers.AfterRetry.Clear()
client.Handlers.AfterRetry.PushBack(
extendedRetryMaxDelayHandlerFactory(submitStateChangeExtraRetries))
client.DefaultMaxRetries = submitStateChangeMaxDelayRetries
return client
}
func (factory *ecrFactory) newClient(region, endpointOverride string) ECRClient {
var ecrConfig aws.Config
ecrConfig.Region = ®ion
ecrConfig.HTTPClient = factory.httpClient
if endpointOverride != "" {
ecrConfig.Endpoint = &endpointOverride
}
sdkClient := ecrapi.New(session.New(&ecrConfig))
tokenCache := async.NewLRUCache(tokenCacheSize, tokenCacheTTL)
return NewECRClient(sdkClient, tokenCache)
}
func newMultiRegion(conf *awsclient.Config, regions []string) *multiRegion {
m := &multiRegion{
regions: make(map[string]*ec2.EC2, 0),
}
for _, region := range regions {
m.regions[region] = ec2.New(conf.Merge(&awsclient.Config{Region: region}))
}
return m
}
func MakeS3Backend(bucket string, prefix string, opts *ConnectOptions) ArchiveBackend {
cfg := aws.Config{}
if opts != nil && opts.S3Region != "" {
cfg.Region = aws.String(opts.S3Region)
}
sess := session.New(&cfg)
return &S3ArchiveBackend{
svc: s3.New(sess),
bucket: bucket,
prefix: prefix,
}
}
func getService(debug bool, profile string) *route53.Route53 {
config := aws.Config{}
if profile != "" {
config.Credentials = credentials.NewSharedCredentials("", profile)
}
// ensures throttled requests are retried
config.MaxRetries = aws.Int(100)
if debug {
config.LogLevel = aws.LogLevel(aws.LogDebug)
}
return route53.New(session.New(), &config)
}
func mergeConfigSrcs(cfg, userCfg *aws.Config, envCfg envConfig, sharedCfg sharedConfig, handlers request.Handlers) {
// Merge in user provided configuration
cfg.MergeIn(userCfg)
// Region if not already set by user
if len(aws.StringValue(cfg.Region)) == 0 {
if len(envCfg.Region) > 0 {
cfg.WithRegion(envCfg.Region)
} else if envCfg.EnableSharedConfig && len(sharedCfg.Region) > 0 {
cfg.WithRegion(sharedCfg.Region)
}
}
// Configure credentials if not already set
if cfg.Credentials == credentials.AnonymousCredentials && userCfg.Credentials == nil {
if len(envCfg.Creds.AccessKeyID) > 0 {
cfg.Credentials = credentials.NewStaticCredentialsFromCreds(
envCfg.Creds,
)
} else if envCfg.EnableSharedConfig && len(sharedCfg.AssumeRole.RoleARN) > 0 && sharedCfg.AssumeRoleSource != nil {
cfgCp := *cfg
cfgCp.Credentials = credentials.NewStaticCredentialsFromCreds(
sharedCfg.AssumeRoleSource.Creds,
)
cfg.Credentials = stscreds.NewCredentials(
&Session{
Config: &cfgCp,
Handlers: handlers.Copy(),
},
sharedCfg.AssumeRole.RoleARN,
func(opt *stscreds.AssumeRoleProvider) {
opt.RoleSessionName = sharedCfg.AssumeRole.RoleSessionName
if len(sharedCfg.AssumeRole.ExternalID) > 0 {
opt.ExternalID = aws.String(sharedCfg.AssumeRole.ExternalID)
}
// MFA not supported
},
)
} else if len(sharedCfg.Creds.AccessKeyID) > 0 {
cfg.Credentials = credentials.NewStaticCredentialsFromCreds(
sharedCfg.Creds,
)
} else {
// Fallback to default credentials provider
cfg.Credentials = credentials.NewCredentials(
defaults.RemoteCredProvider(*cfg, handlers),
)
}
}
}
func getConfig(c *cli.Context) *aws.Config {
debug := c.Bool("debug")
profile := c.String("profile")
config := aws.Config{}
if profile != "" {
config.Credentials = credentials.NewSharedCredentials("", profile)
}
// ensures throttled requests are retried
config.MaxRetries = aws.Int(100)
if debug {
config.LogLevel = aws.LogLevel(aws.LogDebug)
}
return &config
}
func (t *Test) invokeLambdas(awsConfig *aws.Config, sqsURL string) {
lambdas := numberOfLambdas(t.config.Concurrency, len(t.config.Regions))
for i := 0; i < lambdas; i++ {
region := t.config.Regions[i%len(t.config.Regions)]
requests, requestsRemainder := divide(t.config.TotalRequests, lambdas)
concurrency, _ := divide(t.config.Concurrency, lambdas)
if requestsRemainder > 0 && i == lambdas-1 {
requests += requestsRemainder
}
c := t.config
args := []string{
"-u",
fmt.Sprintf("%s", c.URL),
"-c",
fmt.Sprintf("%s", strconv.Itoa(int(concurrency))),
"-n",
fmt.Sprintf("%s", strconv.Itoa(int(requests))),
"-s",
fmt.Sprintf("%s", sqsURL),
"-q",
fmt.Sprintf("%s", c.Regions[0]),
"-t",
fmt.Sprintf("%s", c.RequestTimeout.String()),
"-f",
fmt.Sprintf("%s", reportingFrequency(lambdas).String()),
"-r",
fmt.Sprintf("%s", region),
"-m",
fmt.Sprintf("%s", c.Method),
"-b",
fmt.Sprintf("%s", c.Body),
}
for _, v := range t.config.Headers {
args = append(args, "-H", fmt.Sprintf("%s", v))
}
invokeargs := invokeArgs{
File: "./goad-lambda",
Args: args,
}
config := awsConfig.WithRegion(region)
go t.invokeLambda(config, invokeargs)
}
}
// New creates an instance of the DynamoDB struct for us.
func New(access string, secret string, region string, tableName string) (DynamoDB, error) {
creds := credentials.NewStaticCredentials(access, secret, "")
cfg := aws.Config{
Region: aws.String(region),
}
cfg.WithCredentials(creds)
ddb := DynamoDB{
Table: tableName,
Conn: dynamodb.New(session.New(), &cfg),
}
return ddb, nil
}
// getSessionWithConfig grabs the region and appends to the current config
func getSessionWithConfig(config *aws.Config) (*session.Session, error) {
region, err := getAWSRegion()
if profileName != "" {
fmt.Println("Profile: ", *profile)
} else {
fmt.Println("Profile: default")
}
if region != "" {
fmt.Println("Region: ", region)
config = config.WithRegion(region)
}
fmt.Println()
return session.New(config), err
}
func NewECSClient(credentialProvider *credentials.Credentials, config *config.Config, httpClient *http.Client, ec2MetadataClient ec2.EC2MetadataClient) ECSClient {
var ecsConfig aws.Config
ecsConfig.Credentials = credentialProvider
ecsConfig.Region = &config.AWSRegion
ecsConfig.HTTPClient = httpClient
if config.APIEndpoint != "" {
ecsConfig.Endpoint = &config.APIEndpoint
}
standardClient := ecs.New(&ecsConfig)
submitStateChangeClient := newSubmitStateChangeClient(&ecsConfig)
return &ApiECSClient{
credentialProvider: credentialProvider,
config: config,
standardClient: standardClient,
submitStateChangeClient: submitStateChangeClient,
ec2metadata: ec2MetadataClient,
}
}
func setOptionalEndpoint(cfg *aws.Config) string {
endpoint := os.Getenv("AWS_METADATA_URL")
if endpoint != "" {
log.Printf("[INFO] Setting custom metadata endpoint: %q", endpoint)
cfg.Endpoint = aws.String(endpoint)
return endpoint
}
return ""
}
func NewGoofys(bucket string, awsConfig *aws.Config, flags *FlagStorage) *Goofys {
// Set up the basic struct.
fs := &Goofys{
bucket: bucket,
flags: flags,
umask: 0122,
}
if flags.DebugS3 {
awsConfig.LogLevel = aws.LogLevel(aws.LogDebug | aws.LogDebugWithRequestErrors)
s3Log.Level = logrus.DebugLevel
}
fs.awsConfig = awsConfig
fs.sess = session.New(awsConfig)
fs.s3 = fs.newS3()
err := fs.detectBucketLocation()
if err != nil {
return nil
}
now := time.Now()
fs.rootAttrs = fuseops.InodeAttributes{
Size: 4096,
Nlink: 2,
Mode: flags.DirMode | os.ModeDir,
Atime: now,
Mtime: now,
Ctime: now,
Crtime: now,
Uid: fs.flags.Uid,
Gid: fs.flags.Gid,
}
fs.bufferPool = BufferPool{}.Init()
fs.nextInodeID = fuseops.RootInodeID + 1
fs.inodes = make(map[fuseops.InodeID]*Inode)
root := NewInode(aws.String(""), aws.String(""), flags)
root.Id = fuseops.RootInodeID
root.Attributes = &fs.rootAttrs
fs.inodes[fuseops.RootInodeID] = root
fs.inodesCache = make(map[string]*Inode)
fs.nextHandleID = 1
fs.dirHandles = make(map[fuseops.HandleID]*DirHandle)
fs.fileHandles = make(map[fuseops.HandleID]*FileHandle)
return fs
}
func main() {
var (
region = ""
follow = false
limit = 100
startStr string
startTime time.Time
endStr string
endTime time.Time
config aws.Config
)
flag.StringVar(®ion, "region", region, "AWS region name")
flag.BoolVar(&follow, "f", follow, "output appended data as the logs grow (conflicts with -t and -T)")
flag.IntVar(&limit, "n", limit, "specify the number of lines to output (conflicts with -T)")
flag.StringVar(&startStr, "t", startStr, "load messages since YYYY-MM-DDTHH:MM:SS@TZ (conflicts with -f)")
flag.StringVar(&endStr, "T", endStr, "load messages until YYYY-MM-DDTHH:MM:SS@TZ (conflicts with -n)")
flag.Parse()
if startStr != "" {
startTime = parseTime(startStr)
}
if endStr != "" {
endTime = parseTime(endStr)
}
if region != "" {
config.Region = ®ion
}
sess := session.New(&config)
if err := awslogtail.Run(sess, flag.Args(), follow, limit, startTime, endTime); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
}
// NewClient returns a new EC2Metadata client. Should be used to create
// a client when not using a session. Generally using just New with a session
// is preferred.
func NewClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion string, opts ...func(*client.Client)) *EC2Metadata {
if cfg.HTTPClient == nil || reflect.DeepEqual(*cfg.HTTPClient, http.Client{}) {
// If a unmodified default http client is provided it is safe to add
// custom timeouts.
httpClient := *http.DefaultClient
if t, ok := http.DefaultTransport.(*http.Transport); ok {
transport := *t
transport.Dial = (&net.Dialer{
// use a shorter timeout than default because the metadata
// service is local if it is running, and to fail faster
// if not running on an ec2 instance.
Timeout: 5 * time.Second,
KeepAlive: 30 * time.Second,
}).Dial
httpClient.Transport = &transport
}
cfg.HTTPClient = &httpClient
}
svc := &EC2Metadata{
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: ServiceName,
Endpoint: endpoint,
APIVersion: "latest",
},
handlers,
),
}
svc.Handlers.Unmarshal.PushBack(unmarshalHandler)
svc.Handlers.UnmarshalError.PushBack(unmarshalError)
svc.Handlers.Validate.Clear()
svc.Handlers.Validate.PushBack(validateEndpointHandler)
// Add additional options to the service config
for _, option := range opts {
option(svc.Client)
}
return svc
}
// NewClient returns a new EC2Metadata client. Should be used to create
// a client when not using a session. Generally using just New with a session
// is preferred.
func NewClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion string, opts ...func(*client.Client)) *EC2Metadata {
// If the default http client is provided, replace it with a custom
// client using default timeouts.
if cfg.HTTPClient == http.DefaultClient {
cfg.HTTPClient = &http.Client{
Transport: &http.Transport{
Proxy: http.ProxyFromEnvironment,
Dial: (&net.Dialer{
// use a shorter timeout than default because the metadata
// service is local if it is running, and to fail faster
// if not running on an ec2 instance.
Timeout: 5 * time.Second,
KeepAlive: 30 * time.Second,
}).Dial,
TLSHandshakeTimeout: 10 * time.Second,
},
}
}
svc := &EC2Metadata{
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: ServiceName,
Endpoint: endpoint,
APIVersion: "latest",
},
handlers,
),
}
svc.Handlers.Unmarshal.PushBack(unmarshalHandler)
svc.Handlers.UnmarshalError.PushBack(unmarshalError)
svc.Handlers.Validate.Clear()
svc.Handlers.Validate.PushBack(validateEndpointHandler)
// Add additional options to the service config
for _, option := range opts {
option(svc.Client)
}
return svc
}
func (key MasterKey) createStsSession(config aws.Config, sess *session.Session) (*session.Session, error) {
hostname, err := os.Hostname()
if err != nil {
return nil, err
}
stsService := sts.New(sess)
name := "sops@" + hostname
out, err := stsService.AssumeRole(&sts.AssumeRoleInput{
RoleArn: &key.Role, RoleSessionName: &name})
if err != nil {
return nil, fmt.Errorf("Failed to assume role %q: %v", key.Role, err)
}
config.Credentials = credentials.NewStaticCredentials(*out.Credentials.AccessKeyId,
*out.Credentials.SecretAccessKey, *out.Credentials.SessionToken)
sess, err = session.NewSession(&config)
if err != nil {
return nil, fmt.Errorf("Failed to create new aws session: %v", err)
}
return sess, nil
}
// NewClient returns a new EC2Metadata client. Should be used to create
// a client when not using a session. Generally using just New with a session
// is preferred.
//
// If an unmodified HTTP client is provided from the stdlib default, or no client
// the EC2RoleProvider's EC2Metadata HTTP client's timeout will be shortened.
// To disable this set Config.EC2MetadataDisableTimeoutOverride to false. Enabled by default.
func NewClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion string, opts ...func(*client.Client)) *EC2Metadata {
if !aws.BoolValue(cfg.EC2MetadataDisableTimeoutOverride) && httpClientZero(cfg.HTTPClient) {
// If the http client is unmodified and this feature is not disabled
// set custom timeouts for EC2Metadata requests.
cfg.HTTPClient = &http.Client{
// use a shorter timeout than default because the metadata
// service is local if it is running, and to fail faster
// if not running on an ec2 instance.
Timeout: 5 * time.Second,
}
}
svc := &EC2Metadata{
Client: client.New(
cfg,
metadata.ClientInfo{
ServiceName: ServiceName,
Endpoint: endpoint,
APIVersion: "latest",
},
handlers,
),
}
svc.Handlers.Unmarshal.PushBack(unmarshalHandler)
svc.Handlers.UnmarshalError.PushBack(unmarshalError)
svc.Handlers.Validate.Clear()
svc.Handlers.Validate.PushBack(validateEndpointHandler)
// Add additional options to the service config
for _, option := range opts {
option(svc.Client)
}
return svc
}
// WithRetryer sets a config Retryer value to the given Config returning it
// for chaining.
func WithRetryer(cfg *aws.Config, retryer Retryer) *aws.Config {
cfg.Retryer = retryer
return cfg
}
func NewGoofys(bucket string, awsConfig *aws.Config, flags *flagStorage) *Goofys {
// Set up the basic struct.
fs := &Goofys{
bucket: bucket,
flags: flags,
umask: 0122,
}
if flags.DebugS3 {
awsConfig.LogLevel = aws.LogLevel(aws.LogDebug)
}
fs.awsConfig = awsConfig
fs.s3 = s3.New(awsConfig)
params := &s3.GetBucketLocationInput{Bucket: &bucket}
resp, err := fs.s3.GetBucketLocation(params)
var fromRegion, toRegion string
if err != nil {
if mapAwsError(err) == fuse.ENOENT {
log.Printf("bucket %v does not exist", bucket)
return nil
}
fromRegion, toRegion = parseRegionError(err)
} else {
fs.logS3(resp)
if resp.LocationConstraint == nil {
toRegion = "us-east-1"
} else {
toRegion = *resp.LocationConstraint
}
fromRegion = *awsConfig.Region
}
if len(toRegion) != 0 && fromRegion != toRegion {
log.Printf("Switching from region '%v' to '%v'", fromRegion, toRegion)
awsConfig.Region = &toRegion
fs.s3 = s3.New(awsConfig)
_, err = fs.s3.GetBucketLocation(params)
if err != nil {
log.Println(err)
return nil
}
} else if len(toRegion) == 0 && *awsConfig.Region != "milkyway" {
log.Printf("Unable to detect bucket region, staying at '%v'", *awsConfig.Region)
}
now := time.Now()
fs.rootAttrs = fuseops.InodeAttributes{
Size: 4096,
Nlink: 2,
Mode: flags.DirMode | os.ModeDir,
Atime: now,
Mtime: now,
Ctime: now,
Crtime: now,
Uid: fs.flags.Uid,
Gid: fs.flags.Gid,
}
fs.bufferPool = NewBufferPool(100*1024*1024, 20*1024*1024)
fs.nextInodeID = fuseops.RootInodeID + 1
fs.inodes = make(map[fuseops.InodeID]*Inode)
root := NewInode(aws.String(""), aws.String(""), flags)
root.Id = fuseops.RootInodeID
root.Attributes = &fs.rootAttrs
fs.inodes[fuseops.RootInodeID] = root
fs.inodesCache = make(map[string]*Inode)
fs.nextHandleID = 1
fs.dirHandles = make(map[fuseops.HandleID]*DirHandle)
fs.fileHandles = make(map[fuseops.HandleID]*FileHandle)
return fs
}
func instances(args instancesArgs, config *aws.Config) {
zone := lookupZone(args.name)
fmt.Println("Getting DNS records")
describeInstancesInput := ec2.DescribeInstancesInput{}
if args.off == "" {
filter := ec2.Filter{
Name: aws.String("instance-state-name"),
Values: []*string{aws.String("running")},
}
describeInstancesInput.Filters = []*ec2.Filter{&filter}
}
var reMatch *regexp.Regexp
if args.match != "" {
var err error
reMatch, err = regexp.Compile(args.match)
if err != nil {
fatalIfErr(err)
}
}
insts := map[string]*ec2.Instance{}
for _, region := range args.regions {
ec2conn := ec2.New(session.New(), config.WithRegion(region))
for {
// paginated
output, err := ec2conn.DescribeInstances(&describeInstancesInput)
fatalIfErr(err)
for _, r := range output.Reservations {
for _, i := range r.Instances {
for _, tag := range i.Tags {
// limit to instances with a Name tag
if *tag.Key == "Name" {
if reMatch != nil && !reMatch.MatchString(*tag.Value) {
continue
}
insts[*tag.Value] = i
continue
}
}
}
}
if output.NextToken == nil {
break
}
describeInstancesInput.NextToken = output.NextToken
}
}
if len(insts) == 0 {
fmt.Println("No instances found")
}
var rtype string
if args.aRecord {
rtype = "A"
} else {
rtype = "CNAME"
}
suffix := "." + *zone.Name
suffix = strings.TrimSuffix(suffix, ".")
upserts := []*route53.Change{}
for name, instance := range insts {
var value *string
if *instance.State.Name != "running" {
value = &args.off
} else if args.aRecord {
if args.internal {
value = instance.PrivateIpAddress
} else {
value = instance.PublicIpAddress
}
} else {
if args.internal {
value = aws.String(*instance.PrivateDnsName + ".")
} else {
value = aws.String(*instance.PublicDnsName + ".")
}
}
// add domain suffix if missing
dnsname := name
if !strings.HasSuffix(dnsname, suffix) {
dnsname += suffix
}
rr := route53.ResourceRecord{
Value: value,
}
rrset := route53.ResourceRecordSet{
Name: &dnsname,
TTL: aws.Int64(int64(args.ttl)),
Type: &rtype,
ResourceRecords: []*route53.ResourceRecord{&rr},
}
change := route53.Change{
Action: aws.String("UPSERT"),
ResourceRecordSet: &rrset,
}
upserts = append(upserts, &change)
}
if args.dryRun {
fmt.Println("Dry-run, upserts that would be made:")
for _, upsert := range upserts {
rr := upsert.ResourceRecordSet
fmt.Printf("+ %s %s %v\n", *rr.Name, *rr.Type, *rr.ResourceRecords[0].Value)
}
} else {
resp := batchChanges(upserts, []*route53.Change{}, zone)
fmt.Printf("%d records upserted\n", len(upserts))
if args.wait && resp != nil {
waitForChange(resp.ChangeInfo)
}
}
}
func getService() *route53.Route53 {
config := aws.Config{}
// ensures throttled requests are retried
config.MaxRetries = aws.Int(100)
return route53.New(session.New(), &config)
}
func getInstances(region string, maxCacheAge int, profile Profile) (error, map[string]*Instance) {
instances := getInstanceCache(region, profile.Name, maxCacheAge)
if instances != nil {
return nil, instances
}
var creds *credentials.Credentials
if profile.AWSAccessKey != "" && profile.AWSSecretKey != "" {
creds = credentials.NewStaticCredentials(
profile.AWSAccessKey,
profile.AWSSecretKey,
"",
)
} else if profile.AWSProfile != "" {
creds = credentials.NewSharedCredentials(
fmt.Sprintf("%s/.aws/credentials", homeDir),
profile.AWSProfile,
)
} else {
creds = credentials.NewEnvCredentials()
}
config := aws.Config{Credentials: creds}
if region != "" {
config.Region = aws.String(region)
}
svc := ec2.New(session.New(), &config)
resp, err := svc.DescribeInstances(nil)
if err != nil {
return err, nil
}
instances = make(map[string]*Instance)
for _, res := range resp.Reservations {
for _, inst := range res.Instances {
instance := new(Instance)
instance.Tags = make([]string, len(inst.Tags))
for index, keys := range inst.Tags {
instance.Tags[index] = *keys.Value
if *keys.Key == "Name" {
instance.Name = *keys.Value
instance.Id = *inst.InstanceId
}
}
instance.PublicDnsName = *inst.PublicDnsName
instance.InstanceType = *inst.InstanceType
instance.CertName = *inst.KeyName
if inst.PublicIpAddress != nil {
instance.Addr = *inst.PublicIpAddress
} else if inst.PrivateIpAddress != nil {
instance.Addr = *inst.PrivateIpAddress
}
if instance.Name != "" && instance.Addr != "" {
instances[instance.getNormalisedName()] = instance
}
}
}
if err = storeInstanceCache(region, profile.Name, instances); err != nil {
return err, nil
}
return nil, instances
}