}),
TimeoutMs: 10000,
},
}
desiredLRP1.Action = &models.Action{
TimeoutAction: &models.TimeoutAction{
Action: models.WrapAction(&models.UploadAction{
From: "web_location",
}),
TimeoutMs: 20000,
},
}
desiredLRP1.Monitor = &models.Action{
TimeoutAction: &models.TimeoutAction{
Action: models.WrapAction(&models.UploadAction{
From: "web_location",
}),
TimeoutMs: 30000,
},
}
})
It("translates the timeoutMs to timeout", func() {
Expect(responseRecorder.Code).To(Equal(http.StatusOK))
response := models.DesiredLRPsResponse{}
err := response.Unmarshal(responseRecorder.Body.Bytes())
Expect(err).NotTo(HaveOccurred())
Expect(response.Error).To(BeNil())
Expect(response.DesiredLrps).To(HaveLen(2))
Expect(response.DesiredLrps[0]).To(Equal(desiredLRP1.VersionDownTo(format.V0)))
Expect(response.DesiredLrps[1]).To(Equal(desiredLRP2.VersionDownTo(format.V0)))
BeforeEach(func() {
processGuid = "process-guid-1"
desiredLRP = model_helpers.NewValidDesiredLRP(processGuid)
desiredLRP.DeprecatedStartTimeoutS = 15
desiredLRP.Action = models.WrapAction(&models.TimeoutAction{Action: models.WrapAction(&models.RunAction{Path: "ls", User: "******"}),
DeprecatedTimeoutNs: 4 * int64(time.Second),
})
desiredLRP.Setup = models.WrapAction(&models.TimeoutAction{Action: models.WrapAction(&models.RunAction{Path: "ls", User: "******"}),
DeprecatedTimeoutNs: 7 * int64(time.Second),
})
desiredLRP.Monitor = models.WrapAction(models.EmitProgressFor(
&models.TimeoutAction{
Action: models.WrapAction(models.Try(models.Parallel(models.Serial(&models.RunAction{Path: "ls", User: "******"})))),
DeprecatedTimeoutNs: 10 * int64(time.Second),
},
"start-message",
"success-message",
"failure-message",
))
})
JustBeforeEach(func() {
schedulingInfo, runInfo := desiredLRP.CreateComponents(fakeClock.Now())
runInfo.DeprecatedStartTimeoutS = 15
_, err := json.Marshal(desiredLRP.Routes)
Expect(err).NotTo(HaveOccurred())
schedInfoData, err := serializer.Marshal(logger, format.ENCRYPTED_PROTO, &schedulingInfo)
Expect(err).NotTo(HaveOccurred())
Path: "/the/path",
User: "******",
},
10*time.Millisecond,
))
desiredLRP.Action = models.WrapAction(models.Timeout(
&models.RunAction{
Path: "/the/path",
User: "******",
},
20*time.Millisecond,
))
desiredLRP.Monitor = models.WrapAction(models.Timeout(
&models.RunAction{
Path: "/the/path",
User: "******",
},
30*time.Millisecond,
))
desiredLRP.StartTimeoutMs = 10000
})
It("converts TimeoutMs to Timeout in Nanoseconds", func() {
desiredLRP.VersionDownTo(format.V1)
Expect(desiredLRP.GetSetup().GetTimeoutAction().DeprecatedTimeoutNs).To(BeEquivalentTo(10 * time.Millisecond))
Expect(desiredLRP.GetAction().GetTimeoutAction().DeprecatedTimeoutNs).To(BeEquivalentTo(20 * time.Millisecond))
Expect(desiredLRP.GetMonitor().GetTimeoutAction().DeprecatedTimeoutNs).To(BeEquivalentTo(30 * time.Millisecond))
})
It("converts StartTimeoutMs to StartTimeout in seconds", func() {
desiredLRP.VersionDownTo(format.V1)
