func checkSingleIdle(oc *exutil.CLI, idlingFile string, resources map[string][]string, resourceName string, kind string) {
g.By("Idling the service")
_, err := oc.Run("idle").Args("--resource-names-file", idlingFile).Output()
o.Expect(err).ToNot(o.HaveOccurred())
g.By("Ensuring the scale is zero (and stays zero)")
objName := resources[resourceName][0]
// make sure we don't get woken up by an incorrect router health check or anything like that
o.Consistently(func() (string, error) {
return oc.Run("get").Args(resourceName+"/"+objName, "--output=jsonpath=\"{.spec.replicas}\"").Output()
}, 20*time.Second, 500*time.Millisecond).Should(o.ContainSubstring("0"))
g.By("Fetching the service and checking the annotations are present")
serviceName := resources["service"][0]
endpoints, err := oc.KubeREST().Endpoints(oc.Namespace()).Get(serviceName)
o.Expect(err).NotTo(o.HaveOccurred())
o.Expect(endpoints.Annotations).To(o.HaveKey(unidlingapi.IdledAtAnnotation))
o.Expect(endpoints.Annotations).To(o.HaveKey(unidlingapi.UnidleTargetAnnotation))
g.By("Checking the idled-at time")
idledAtAnnotation := endpoints.Annotations[unidlingapi.IdledAtAnnotation]
idledAtTime, err := time.Parse(time.RFC3339, idledAtAnnotation)
o.Expect(err).ToNot(o.HaveOccurred())
o.Expect(idledAtTime).To(o.BeTemporally("~", time.Now(), 5*time.Minute))
g.By("Checking the idle targets")
unidleTargetAnnotation := endpoints.Annotations[unidlingapi.UnidleTargetAnnotation]
unidleTargets := []unidlingapi.RecordedScaleReference{}
err = json.Unmarshal([]byte(unidleTargetAnnotation), &unidleTargets)
o.Expect(err).ToNot(o.HaveOccurred())
o.Expect(unidleTargets).To(o.Equal([]unidlingapi.RecordedScaleReference{
{
Replicas: 2,
CrossGroupObjectReference: unidlingapi.CrossGroupObjectReference{
Name: resources[resourceName][0],
Kind: kind,
},
},
}))
}
})
It("should perform", func() {
g.Expect(subject.perform(mockFact{FactKey(33): []int64{1}}, NewState())).To(g.BeTrue())
g.Expect(subject.perform(mockFact{FactKey(33): []int64{4}}, NewState())).To(g.BeFalse())
g.Expect(subject.perform(mockFact{FactKey(34): []int64{1}}, NewState())).To(g.BeFalse())
})
It("should capture state", func() {
state := NewState()
g.Expect(subject.perform(mockFact{FactKey(33): []int64{1}}, state)).To(g.BeTrue())
g.Expect(state.rules).To(g.Equal(map[uint64]bool{
3048486384098978521: true,
}))
g.Expect(state.facts).To(g.HaveLen(1))
g.Expect(state.facts).To(g.HaveKey(FactKey(33)))
})
})
var _ = Describe("conjunction", func() {
var subject Rule
BeforeEach(func() {
subject = All(
CheckFact(33, OneOf([]int64{3, 2, 1})),
CheckFact(33, OneOf([]int64{4, 5, 6})),
)
})
It("should return a string", func() {
g.Expect(subject.String()).To(g.Equal(`( [33]+[1 2 3] && [33]+[4 5 6] )`))
serviceName := resources["service"][0]
svc, err := oc.KubeREST().Services(oc.Namespace()).Get(serviceName)
o.Expect(err).ToNot(o.HaveOccurred())
err = tryEchoTCP(svc)
o.Expect(err).ToNot(o.HaveOccurred())
g.By("Waiting until we have endpoints")
err = waitForEndpointsAvailable(oc, serviceName)
o.Expect(err).ToNot(o.HaveOccurred())
endpoints, err := oc.KubeREST().Endpoints(oc.Namespace()).Get(serviceName)
o.Expect(err).ToNot(o.HaveOccurred())
g.By("Making sure the endpoints are no longer marked as idled")
o.Expect(endpoints.Annotations).NotTo(o.HaveKey(unidlingapi.IdledAtAnnotation))
o.Expect(endpoints.Annotations).NotTo(o.HaveKey(unidlingapi.UnidleTargetAnnotation))
})
g.It("should work with TCP (while idling)", func() {
g.By("Idling the service")
_, err := oc.Run("idle").Args("--resource-names-file", idlingFile).Output()
o.Expect(err).ToNot(o.HaveOccurred())
g.By("Connecting to the service IP and repeatedly connecting, making sure we seamlessly idle and come back up")
serviceName := resources["service"][0]
svc, err := oc.KubeREST().Services(oc.Namespace()).Get(serviceName)
o.Expect(err).ToNot(o.HaveOccurred())
o.Consistently(func() error { return tryEchoTCP(svc) }, 10*time.Second, 500*time.Millisecond).ShouldNot(o.HaveOccurred())