func TestMetadataHandler(t *testing.T) {
metadataHandler := metadataV1RequestHandlerMaker(utils.Strptr(testContainerInstanceArn), &config.Config{Cluster: testClusterArn})
w := httptest.NewRecorder()
req, _ := http.NewRequest("GET", "http://localhost:"+strconv.Itoa(config.AgentIntrospectionPort), nil)
metadataHandler(w, req)
var resp MetadataResponse
json.Unmarshal(w.Body.Bytes(), &resp)
if resp.Cluster != testClusterArn {
t.Error("Metadata returned the wrong cluster arn")
}
if *resp.ContainerInstanceArn != testContainerInstanceArn {
t.Error("Metadata returned the wrong cluster arn")
}
}
func performMockRequest(t *testing.T, path string) *httptest.ResponseRecorder {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
mockStateResolver := mock_handlers.NewMockDockerStateResolver(ctrl)
state := dockerstate.NewDockerTaskEngineState()
stateSetupHelper(state, testTasks)
mockStateResolver.EXPECT().State().Return(state)
requestHandler := setupServer(utils.Strptr(testContainerInstanceArn), mockStateResolver, &config.Config{Cluster: testClusterArn})
recorder := httptest.NewRecorder()
req, _ := http.NewRequest("GET", path, nil)
requestHandler.Handler.ServeHTTP(recorder, req)
return recorder
}
func TestServeHttp(t *testing.T) {
taskEngine := engine.NewTaskEngine(&config.Config{})
containers := []*api.Container{
&api.Container{
Name: "c1",
},
}
testTask := api.Task{
Arn: "task1",
DesiredStatus: api.TaskRunning,
KnownStatus: api.TaskRunning,
Family: "test",
Version: "1",
Containers: containers,
}
// Populate Tasks and Container map in the engine.
dockerTaskEngine, _ := taskEngine.(*engine.DockerTaskEngine)
dockerTaskEngine.State().AddTask(&testTask)
dockerTaskEngine.State().AddContainer(&api.DockerContainer{DockerId: "docker1", DockerName: "someName", Container: containers[0]}, &testTask)
go ServeHttp(utils.Strptr(TestContainerInstanceArn), taskEngine, &config.Config{Cluster: TestClusterArn})
body := getResponseBodyFromLocalHost("/v1/metadata", t)
var metadata MetadataResponse
json.Unmarshal(body, &metadata)
if metadata.Cluster != TestClusterArn {
t.Error("Metadata returned the wrong cluster arn")
}
if *metadata.ContainerInstanceArn != TestContainerInstanceArn {
t.Error("Metadata returned the wrong cluster arn")
}
var tasksResponse TasksResponse
body = getResponseBodyFromLocalHost("/v1/tasks", t)
json.Unmarshal(body, &tasksResponse)
tasks := tasksResponse.Tasks
if len(tasks) != 1 {
t.Error("Incorrect number of tasks in response: ", len(tasks))
}
if tasks[0].Arn != "task1" {
t.Error("Incorrect task arn in response: ", tasks[0].Arn)
}
containersResponse := tasks[0].Containers
if len(containersResponse) != 1 {
t.Error("Incorrect number of containers in response: ", len(containersResponse))
}
if containersResponse[0].Name != "c1" {
t.Error("Incorrect container name in response: ", containersResponse[0].Name)
}
var taskResponse TaskResponse
body = getResponseBodyFromLocalHost("/v1/tasks?dockerid=docker1", t)
json.Unmarshal(body, &taskResponse)
if taskResponse.Arn != "task1" {
t.Error("Incorrect task arn in response")
}
if taskResponse.Containers[0].Name != "c1" {
t.Error("Incorrect task arn in response")
}
resp, err := http.Get("http://localhost:" + strconv.Itoa(config.AGENT_INTROSPECTION_PORT) + "/v1/tasks?dockerid=docker2")
if err != nil {
t.Fatal(err)
}
if resp.StatusCode != 400 {
t.Error("API did not return bad request status for invalid docker id")
}
body = getResponseBodyFromLocalHost("/v1/tasks?taskarn=task1", t)
json.Unmarshal(body, &taskResponse)
if taskResponse.Arn != "task1" {
t.Error("Incorrect task arn in response")
}
resp, err = http.Get("http://localhost:" + strconv.Itoa(config.AGENT_INTROSPECTION_PORT) + "/v1/tasks?taskarn=task2")
if resp.StatusCode != 400 {
t.Error("API did not return bad request status for invalid task id")
}
resp, err = http.Get("http://localhost:" + strconv.Itoa(config.AGENT_INTROSPECTION_PORT) + "/v1/tasks?taskarn=")
if resp.StatusCode != 400 {
t.Error("API did not return bad request status for invalid task id")
}
resp, err = http.Get("http://localhost:" + strconv.Itoa(config.AGENT_INTROSPECTION_PORT) + "/v1/tasks?taskarn=task1&dockerid=docker1")
if err != nil {
t.Fatal(err)
}
if resp.StatusCode != 400 {
t.Error("API did not return bad request status when both dockerid and taskarn are specified.")
}
}
func (client *ApiECSClient) registerContainerInstance(clusterRef string) (string, error) {
registerRequest := ecs.RegisterContainerInstanceInput{Cluster: &clusterRef}
instanceIdentityDoc, err := client.ec2metadata.ReadResource(ec2.INSTANCE_IDENTITY_DOCUMENT_RESOURCE)
iidRetrieved := true
if err != nil {
log.Error("Unable to get instance identity document", "err", err)
iidRetrieved = false
instanceIdentityDoc = []byte{}
}
strIid := string(instanceIdentityDoc)
registerRequest.InstanceIdentityDocument = &strIid
instanceIdentitySignature := []byte{}
if iidRetrieved {
instanceIdentitySignature, err = client.ec2metadata.ReadResource(ec2.INSTANCE_IDENTITY_DOCUMENT_SIGNATURE_RESOURCE)
if err != nil {
log.Error("Unable to get instance identity signature", "err", err)
}
}
strIidSig := string(instanceIdentitySignature)
registerRequest.InstanceIdentityDocumentSignature = &strIidSig
// Micro-optimization, the pointer to this is used multiple times below
integerStr := "INTEGER"
cpu, mem := getCpuAndMemory()
mem = mem - int64(client.config.ReservedMemory)
cpuResource := ecs.Resource{
Name: utils.Strptr("CPU"),
Type: &integerStr,
IntegerValue: &cpu,
}
memResource := ecs.Resource{
Name: utils.Strptr("MEMORY"),
Type: &integerStr,
IntegerValue: &mem,
}
portResource := ecs.Resource{
Name: utils.Strptr("PORTS"),
Type: utils.Strptr("STRINGSET"),
StringSetValue: utils.Uint16SliceToStringSlice(client.config.ReservedPorts),
}
udpPortResource := ecs.Resource{
Name: utils.Strptr("PORTS_UDP"),
Type: utils.Strptr("STRINGSET"),
StringSetValue: utils.Uint16SliceToStringSlice(client.config.ReservedPortsUDP),
}
resources := []*ecs.Resource{&cpuResource, &memResource, &portResource, &udpPortResource}
registerRequest.TotalResources = resources
resp, err := client.c.RegisterContainerInstance(®isterRequest)
if err != nil {
log.Error("Could not register", "err", err)
return "", NewAPIError(err)
}
log.Info("Registered!")
return *resp.ContainerInstance.ContainerInstanceARN, nil
}