Exemplo n.º 1
0
			entrances := client.EntranceListener()
			exits := client.ExitListener()

			childRunner2.TriggerReady()
			Eventually(entrances).Should(Receive(&entrance2))
			Ω(entrance2.Member).Should(Equal(member2))

			childRunner1.TriggerReady()
			Eventually(entrances).Should(Receive(&entrance1))
			Ω(entrance1.Member).Should(Equal(member1))

			childRunner3.TriggerReady()
			Eventually(entrances).Should(Receive(&entrance3))
			Ω(entrance3.Member).Should(Equal(member3))

			childRunner2.TriggerExit(nil)
			Eventually(exits).Should(Receive(&exit2))
			Ω(exit2.Member).Should(Equal(member2))

			childRunner1.TriggerExit(nil)
			Eventually(exits).Should(Receive(&exit1))
			Ω(exit1.Member).Should(Equal(member1))

			childRunner3.TriggerExit(nil)
			Eventually(exits).Should(Receive(&exit3))
			Ω(exit3.Member).Should(Equal(member3))
		})

		It("announces the most recent events that have already occured, up to the buffer size", func() {
			entrance2, entrance3 := grouper.EntranceEvent{}, grouper.EntranceEvent{}
			exit2, exit3 := grouper.ExitEvent{}, grouper.ExitEvent{}
Exemplo n.º 2
0
					case runner := <-loadedRunners:
						return runner
					default:
						return nil
					}
				}
				loadedRunner = fake_runner.NewTestRunner()
				loadedRunners <- loadedRunner
			})

			AfterEach(func() {
				loadedRunner.EnsureExit()
			})

			It("executes the returned Runner", func() {
				testRunner.TriggerExit(nil)
				loadedRunner.TriggerExit(nil)
			})
		})

		Context("when load returns nil", func() {
			BeforeEach(func() {
				restarter.Load = func(runner ifrit.Runner, err error) ifrit.Runner {
					return nil
				}
			})

			It("exits after running the initial Runner", func() {
				testRunner.TriggerExit(nil)
				Eventually(process.Wait()).Should(Receive(BeNil()))
			})
Exemplo n.º 3
0
			})

			Describe("when it receives a signal", func() {
				BeforeEach(func() {
					groupProcess.Signal(syscall.SIGUSR2)
				})

				It("sends the signal to all child runners", func() {
					Eventually(signal1).Should(Receive(Equal(syscall.SIGUSR2)))
					Eventually(signal2).Should(Receive(Equal(syscall.SIGUSR2)))
					Eventually(signal3).Should(Receive(Equal(syscall.SIGUSR2)))
				})

				It("doesn't send any more signals to remaining child processes", func() {
					Eventually(signal3).Should(Receive(Equal(syscall.SIGUSR2)))
					childRunner2.TriggerExit(nil)
					Consistently(signal3).ShouldNot(Receive())
				})
			})

			Describe("when a process exits cleanly", func() {
				BeforeEach(func() {
					childRunner1.TriggerExit(nil)
				})

				It("sends an interrupt signal to the other processes", func() {
					Eventually(signal2).Should(Receive(Equal(os.Interrupt)))
					Eventually(signal3).Should(Receive(Equal(os.Interrupt)))
				})

				It("does not exit", func() {