func TestRegisterBlankCluster(t *testing.T) {
mockCtrl := gomock.NewController(t)
defer mockCtrl.Finish()
// Test the special 'empty cluster' behavior of creating 'default'
client := api.NewECSClient(aws.DetectCreds("", "", ""), &config.Config{Cluster: "", AWSRegion: "us-east-1"}, false)
mc := mock_api.NewMockECSSDK(mockCtrl)
client.(*api.ApiECSClient).SetSDK(mc)
mockEC2Metadata := mock_ec2.NewMockEC2MetadataClient(mockCtrl)
client.(*api.ApiECSClient).SetEC2MetadataClient(mockEC2Metadata)
defaultCluster := config.DEFAULT_CLUSTER_NAME
gomock.InOrder(
mockEC2Metadata.EXPECT().ReadResource(ec2.INSTANCE_IDENTITY_DOCUMENT_RESOURCE).Return([]byte("instanceIdentityDocument"), nil),
mockEC2Metadata.EXPECT().ReadResource(ec2.INSTANCE_IDENTITY_DOCUMENT_SIGNATURE_RESOURCE).Return([]byte("signature"), nil),
mc.EXPECT().RegisterContainerInstance(gomock.Any()).Return(nil, aws.Error(errors.New("No such cluster"))),
mc.EXPECT().CreateCluster(&ecs.CreateClusterInput{ClusterName: &defaultCluster}).Return(&ecs.CreateClusterOutput{Cluster: &ecs.Cluster{ClusterName: &defaultCluster}}, nil),
mockEC2Metadata.EXPECT().ReadResource(ec2.INSTANCE_IDENTITY_DOCUMENT_RESOURCE).Return([]byte("instanceIdentityDocument"), nil),
mockEC2Metadata.EXPECT().ReadResource(ec2.INSTANCE_IDENTITY_DOCUMENT_SIGNATURE_RESOURCE).Return([]byte("signature"), nil),
mc.EXPECT().RegisterContainerInstance(gomock.Any()).Do(func(req *ecs.RegisterContainerInstanceInput) {
if *req.Cluster != config.DEFAULT_CLUSTER_NAME {
t.Errorf("Wrong cluster: %v", *req.Cluster)
}
if *req.InstanceIdentityDocument != "instanceIdentityDocument" {
t.Errorf("Wrong IID: %v", *req.InstanceIdentityDocument)
}
if *req.InstanceIdentityDocumentSignature != "signature" {
t.Errorf("Wrong IID sig: %v", *req.InstanceIdentityDocumentSignature)
}
}).Return(&ecs.RegisterContainerInstanceOutput{ContainerInstance: &ecs.ContainerInstance{ContainerInstanceARN: aws.String("registerArn")}}, nil),
)
arn, err := client.RegisterContainerInstance("")
if err != nil {
t.Errorf("Should not be an error: %v", err)
}
if arn != "registerArn" {
t.Errorf("Wrong arn: %v", arn)
}
}
func TestCopySnapshotPresignedURL(t *testing.T) {
svc := ec2.New(&aws.Config{
Credentials: aws.DetectCreds("AKID", "SECRET", ""),
Region: "us-west-2",
})
assert.NotPanics(t, func() {
// Doesn't panic on nil input
req, _ := svc.CopySnapshotRequest(nil)
req.Sign()
})
req, _ := svc.CopySnapshotRequest(&ec2.CopySnapshotInput{
SourceRegion: aws.String("us-west-1"),
SourceSnapshotID: aws.String("snap-id"),
})
req.Sign()
b, _ := ioutil.ReadAll(req.HTTPRequest.Body)
q, _ := url.ParseQuery(string(b))
url, _ := url.QueryUnescape(q.Get("PresignedUrl"))
assert.Equal(t, "us-west-2", q.Get("DestinationRegion"))
assert.Regexp(t, `^https://ec2\.us-west-1\.amazon.+&DestinationRegion=us-west-2`, url)
}
// parseArgs handles CLI flags and env vars
func parseArgs() (*config, error) {
c := config{}
var verPtr bool
var helpPtr bool
flag.BoolVar(&verPtr, "version", false, "print version")
flag.BoolVar(&verPtr, "v", false, "print version")
flag.BoolVar(&helpPtr, "help", false, "print usage")
flag.BoolVar(&helpPtr, "h", false, "print usage")
flag.Parse()
if verPtr {
fmt.Println(version)
os.Exit(0)
} else if helpPtr {
fmt.Println(usage)
os.Exit(0)
}
c.queueURL = os.Getenv("AWS_SQS_URL")
if len(c.queueURL) < 1 {
return nil, fmt.Errorf("Must specify SQS url with -Q flag or by setting AWS_SQS_URL env var.")
}
c.awsKeyId = os.Getenv("AWS_ACCESS_KEY_ID")
c.awsSecret = os.Getenv("AWS_SECRET_ACCESS_KEY")
creds := aws.DetectCreds(c.awsKeyId, c.awsSecret, "")
c.awsConfig = aws.Config{Credentials: creds, Region: c.region}
c.region = os.Getenv("AWS_REGION")
if len(c.region) < 1 {
c.region = "us-east-1"
}
c.esURL = os.Getenv("ES_URL")
if len(c.esURL) < 1 {
c.esURL = "http://127.0.0.1:9200"
}
c.listen = os.Getenv("WEB_LISTEN")
if len(c.listen) < 1 {
c.listen = "0.0.0.0:7000"
}
if len(os.Getenv("DEBUG")) > 0 {
c.debugOn = true
}
if len(os.Getenv("SQS_PERSIST")) > 0 {
c.sqsPersist = true
}
c.sslMode = SSLoff
if len(os.Getenv("SSL_MODE")) > 0 {
var ok bool
c.sslMode, ok = sslModeOptionMap[os.Getenv("SSL_MODE")]
if !ok {
return nil, fmt.Errorf("Invalid SSL_MODE. Must be one of 'off', 'selfSigned', or 'custom'.")
}
}
if c.sslMode != SSLoff {
// look for existing ".tdssl/key.pem" and ".tdssl/cert.pem"
_, keyErr := os.Stat(SSLkeyFile)
_, certErr := os.Stat(SSLcertFile)
if os.IsNotExist(keyErr) && os.IsNotExist(certErr) && c.sslMode == SSLselfSigned {
if _, dirErr := os.Stat(SSLcertDir); os.IsNotExist(dirErr) {
if err := os.Mkdir(SSLcertDir, 0700); err != nil {
return nil, fmt.Errorf("Error creating SSL cert directory at %s: %s", SSLcertDir, err.Error())
}
}
if err := generateCert(SSLcertFile, SSLkeyFile); err != nil {
return nil, fmt.Errorf("Error generating a self-signed SSL cert: %s", err.Error())
}
log.Printf("Created new self-signed SSL cert in %s.", SSLcertDir)
} else if os.IsNotExist(keyErr) || os.IsNotExist(certErr) {
return nil, fmt.Errorf("SSL key or cert missing. Expected at %s and %s", SSLcertFile, SSLkeyFile)
}
}
return &c, nil
}
func NewMockClient(ctrl *gomock.Controller) (api.ECSClient, *mock_api.MockECSSDK) {
client := api.NewECSClient(aws.DetectCreds("", "", ""), &config.Config{Cluster: configuredCluster, AWSRegion: "us-east-1"}, false)
mock := mock_api.NewMockECSSDK(ctrl)
client.(*api.ApiECSClient).SetSDK(mock)
return client, mock
}