func constructRequest(reqGenerator *rata.RequestGenerator, spec atc.HijackProcessSpec, id string, token *rc.TargetToken) *http.Request {
payload, err := json.Marshal(spec)
if err != nil {
log.Fatalln("failed to marshal process spec:", err)
}
hijackReq, err := reqGenerator.CreateRequest(
atc.HijackContainer,
rata.Params{"id": id},
bytes.NewBuffer(payload),
)
if err != nil {
log.Fatalln("failed to create hijack request:", err)
}
if token != nil {
hijackReq.Header.Add("Authorization", token.Type+" "+token.Value)
}
return hijackReq
}
func constructRequest(reqGenerator *rata.RequestGenerator, spec atc.HijackProcessSpec, reqValues url.Values) *http.Request {
payload, err := json.Marshal(spec)
if err != nil {
log.Fatalln("failed to marshal process spec:", err)
}
hijackReq, err := reqGenerator.CreateRequest(
atc.Hijack,
rata.Params{},
bytes.NewBuffer(payload),
)
if err != nil {
log.Fatalln("failed to create hijack request:", err)
}
if hijackReq.URL.User != nil {
hijackReq.Header.Add("Authorization", basicAuth(hijackReq.URL.User))
hijackReq.URL.User = nil
}
hijackReq.URL.RawQuery = reqValues.Encode()
return hijackReq
}
},
},
},
},
},
}
})
Describe("GET /api/v1/pipelines/:name/config", func() {
var (
response *http.Response
)
JustBeforeEach(func() {
req, err := requestGenerator.CreateRequest(atc.GetConfig, rata.Params{
"pipeline_name": "something-else",
}, nil)
Expect(err).NotTo(HaveOccurred())
response, err = client.Do(req)
Expect(err).NotTo(HaveOccurred())
})
Context("when authenticated", func() {
BeforeEach(func() {
authValidator.IsAuthenticatedReturns(true)
})
Context("when the config can be loaded", func() {
BeforeEach(func() {
configDB.GetConfigReturns(config, 1, nil)
})
AfterEach(func() {
cliRunner.StopAPIServer()
})
Context("when the store is fresh", func() {
BeforeEach(func() {
simulator.Tick(simulator.TicksToAttainFreshness)
cliRunner.StartAPIServer(simulator.currentTimestamp)
})
It("returns the apps", func() {
getAppstatus, err := requestGenerator.CreateRequest(
"bulk_app_state",
nil,
bytes.NewBufferString(validRequest),
)
Expect(err).NotTo(HaveOccurred())
getAppstatus.SetBasicAuth(username, password)
response, err := httpClient.Do(getAppstatus)
Expect(err).NotTo(HaveOccurred())
defer response.Body.Close()
Expect(response.StatusCode).To(Equal(http.StatusOK))
bodyBytes, err := ioutil.ReadAll(response.Body)
Expect(err).NotTo(HaveOccurred())
bodyString := string(bodyBytes)
instanceKey0 := models.NewActualLRPInstanceKey("some-instance-guid-0", "cell-id")
err := bbsClient.ClaimActualLRP("some-process-guid", 0, &instanceKey0)
Expect(err).NotTo(HaveOccurred())
lrpKey1 := models.NewActualLRPKey("some-process-guid", 1, "some-domain")
instanceKey1 := models.NewActualLRPInstanceKey("some-instance-guid-1", "cell-id")
netInfo := models.NewActualLRPNetInfo("1.2.3.4", models.NewPortMapping(65100, 8080))
err = bbsClient.StartActualLRP(&lrpKey1, &instanceKey1, &netInfo)
Expect(err).NotTo(HaveOccurred())
})
It("reports the state of the given process guid's instances", func() {
getLRPs, err := requestGenerator.CreateRequest(
tps.LRPStatus,
rata.Params{"guid": "some-process-guid"},
nil,
)
Expect(err).NotTo(HaveOccurred())
response, err := httpClient.Do(getLRPs)
Expect(err).NotTo(HaveOccurred())
var lrpInstances []cc_messages.LRPInstance
err = json.NewDecoder(response.Body).Decode(&lrpInstances)
Expect(err).NotTo(HaveOccurred())
Expect(lrpInstances).To(HaveLen(3))
for i, _ := range lrpInstances {
Expect(lrpInstances[i]).NotTo(BeZero())
lrpInstances[i].Since = 0
func getBuild(client *http.Client, reqGenerator *rata.RequestGenerator, jobName string, buildName string, pipelineName string) atc.Build {
if pipelineName != "" && jobName == "" {
fmt.Fprintln(os.Stderr, "job must be specified if pipeline is specified")
os.Exit(1)
}
if pipelineName == "" {
pipelineName = atc.DefaultPipelineName
}
if buildName != "" {
var buildReq *http.Request
var err error
if jobName != "" {
buildReq, err = reqGenerator.CreateRequest(
atc.GetJobBuild,
rata.Params{
"job_name": jobName,
"build_name": buildName,
"pipeline_name": pipelineName,
},
nil,
)
} else {
buildReq, err = reqGenerator.CreateRequest(
atc.GetBuild,
rata.Params{"build_id": buildName},
nil,
)
}
if err != nil {
log.Fatalln("failed to create request", err)
}
buildResp, err := client.Do(buildReq)
if err != nil {
log.Fatalln("failed to get builds:", err)
}
if buildResp.StatusCode != http.StatusOK {
log.Println("bad response when getting build:")
buildResp.Body.Close()
buildResp.Write(os.Stderr)
os.Exit(1)
}
var build atc.Build
err = json.NewDecoder(buildResp.Body).Decode(&build)
if err != nil {
log.Fatalln("failed to decode job:", err)
}
return build
} else if jobName != "" {
jobReq, err := reqGenerator.CreateRequest(
atc.GetJob,
rata.Params{"job_name": jobName, "pipeline_name": pipelineName},
nil,
)
if err != nil {
log.Fatalln("failed to create request", err)
}
jobResp, err := client.Do(jobReq)
if err != nil {
log.Fatalln("failed to get builds:", err)
}
if jobResp.StatusCode != http.StatusOK {
log.Println("bad response when getting job:")
jobResp.Body.Close()
jobResp.Write(os.Stderr)
os.Exit(1)
}
var job atc.Job
err = json.NewDecoder(jobResp.Body).Decode(&job)
if err != nil {
log.Fatalln("failed to decode job:", err)
}
if job.NextBuild != nil {
return *job.NextBuild
} else if job.FinishedBuild != nil {
return *job.FinishedBuild
} else {
println("job has no builds")
os.Exit(1)
}
} else {
buildsReq, err := reqGenerator.CreateRequest(
atc.ListBuilds,
nil,
nil,
)
if err != nil {
log.Fatalln("failed to create request", err)
}
buildsResp, err := client.Do(buildsReq)
if err != nil {
log.Fatalln("failed to get builds:", err)
}
if buildsResp.StatusCode != http.StatusOK {
log.Println("bad response when getting builds:")
buildsResp.Body.Close()
buildsResp.Write(os.Stderr)
os.Exit(1)
}
var builds []atc.Build
err = json.NewDecoder(buildsResp.Body).Decode(&builds)
if err != nil {
log.Fatalln("failed to decode builds:", err)
}
for _, build := range builds {
if build.JobName == "" {
return build
}
}
println("no builds")
os.Exit(1)
}
panic("unreachable")
}
err = desireTaskRequest.Unmarshal(data)
Expect(err).NotTo(HaveOccurred())
Expect(desireTaskRequest.TaskDefinition.MemoryMb).To(Equal(int32(1024)))
Expect(desireTaskRequest.TaskDefinition.DiskMb).To(Equal(int32(128)))
Expect(desireTaskRequest.TaskDefinition.CompletionCallbackUrl).To(Equal(callbackURL))
})
req, err := requestGenerator.CreateRequest(stager.StageRoute, rata.Params{"staging_guid": "my-task-guid"}, strings.NewReader(`{
"app_id":"my-app-guid",
"file_descriptors":3,
"memory_mb" : 1024,
"disk_mb" : 128,
"environment" : [],
"lifecycle": "buildpack",
"lifecycle_data": {
"buildpacks" : [],
"stack":"linux",
"app_bits_download_uri":"http://example.com/app_bits"
}
}`))
Expect(err).NotTo(HaveOccurred())
req.Header.Set("Content-Type", "application/json")
resp, err := httpClient.Do(req)
Expect(err).NotTo(HaveOccurred())
Expect(resp.StatusCode).To(Equal(http.StatusAccepted))
Eventually(fakeBBS.ReceivedRequests).Should(HaveLen(1))
Consistently(runner.Session()).ShouldNot(gexec.Exit())
process ifrit.Process
)
requestDesireWithInstances := func(nInstances int) (*http.Response, error) {
req, err := requestGenerator.CreateRequest(nsync.DesireAppRoute, rata.Params{"process_guid": "the-guid"}, strings.NewReader(`{
"process_guid": "the-guid",
"droplet_uri": "http://the-droplet.uri.com",
"start_command": "the-start-command",
"execution_metadata": "execution-metadata-1",
"memory_mb": 128,
"disk_mb": 512,
"file_descriptors": 32,
"num_instances": `+strconv.Itoa(nInstances)+`,
"stack": "some-stack",
"log_guid": "the-log-guid",
"health_check_timeout_in_seconds": 123456,
"ports": [8080,5222],
"etag": "2.1",
"routing_info": {
"http_routes": [
{"hostname": "route-1"}
],
"tcp_routes": [
{"router_group_guid": "guid-1", "external_port":5222, "container_port":60000}
]
}
}`))
Expect(err).NotTo(HaveOccurred())
req.Header.Set("Content-Type", "application/json")
return httpClient.Do(req)