示例#1
0
				Expect(fakeRunner).ToNot(HaveExecutedSerially(
					fake_command_runner.CommandSpec{
						Path: "setquota",
					},
				))
			})
		})
	})

	Describe("getting quotas limits", func() {
		It("executes repquota in the root path", func(done Done) {
			fakeRunner.WhenWaitingFor(
				fake_command_runner.CommandSpec{
					Path: "/root/path/repquota",
				}, func(cmd *exec.Cmd) error {
					close(done)
					return nil
				},
			)

			fakeRunner.WhenRunning(
				fake_command_runner.CommandSpec{
					Path: "/root/path/repquota",
					Args: []string{"/some/mount/point", "1234"},
				}, func(cmd *exec.Cmd) error {
					cmd.Stdout.Write([]byte("1234 111 222 333 444 555 666 777 888\n"))

					return nil
				},
			)
					Eventually(oomChan).Should(BeClosed())
				})
			})

			Context("when the oom process does not exit", func() {
				var waitReturns chan struct{}

				BeforeEach(func() {
					waitReturns = make(chan struct{})

					runner.WhenWaitingFor(
						fake_command_runner.CommandSpec{
							Path: path.Join(containerPath, "bin", "oom"),
						},
						func(cmd *exec.Cmd) error {
							<-waitReturns
							return nil
						},
					)
				})

				AfterEach(func() {
					close(waitReturns)

					Eventually(oomChan).Should(BeClosed())
				})

				It("does not notify", func() {
					Expect(oomNotifier.Watch(oNoom)).To(Succeed())
					time.Sleep(100 * time.Millisecond)

					Expect(fakeRunner).ToNot(HaveStartedExecuting(
						fake_command_runner.CommandSpec{
							Path: binPath("iomux-link"),
						},
					), "Executed iomux-link too early!")

					Expect(cmd.Stdout).ToNot(BeNil())

					fakeRunner.WhenWaitingFor(
						fake_command_runner.CommandSpec{
							Path: binPath("iomux-link"),
						},
						func(*exec.Cmd) error {
							close(done)
							return nil
						},
					)

					cmd.Stdout.Write([]byte("xxx\n"))

					Eventually(fakeRunner).Should(HaveStartedExecuting(
						fake_command_runner.CommandSpec{
							Path: binPath("iomux-link"),
						},
					))
				}()

				return nil
示例#4
0
				}(eventsCh, cmd.Stdout.(io.WriteCloser))

				return nil
			})

			eventsNotifier = new(fakes.FakeEventsNotifier)
		})

		It("reports an event if one happens", func() {
			defer close(eventsCh)

			waitCh := make(chan struct{})
			defer close(waitCh)
			commandRunner.WhenWaitingFor(fake_command_runner.CommandSpec{
				Path: "funC-events",
			}, func(cmd *exec.Cmd) error {
				<-waitCh
				return nil
			})

			go runner.WatchEvents(logger, "some-container", eventsNotifier)

			Consistently(eventsNotifier.OnEventCallCount).Should(Equal(0))

			eventsCh <- `{"type":"oom"}`
			Eventually(eventsNotifier.OnEventCallCount).Should(Equal(1))
			handle, event := eventsNotifier.OnEventArgsForCall(0)
			Expect(handle).To(Equal("some-container"))
			Expect(event).To(Equal("Out of memory"))

			eventsCh <- `{"type":"oom"}`
			Eventually(eventsNotifier.OnEventCallCount).Should(Equal(2))
			))
		})

		It("returns error if fails to start a shell command", func() {
			runner.WhenRunning(fake_command_runner.CommandSpec{}, func(*exec.Cmd) error {
				return errors.New("what")
			})

			step := &containerizer.ShellRunnerStep{Runner: runner, Path: path}
			err := step.Run()
			Expect(err).To(HaveOccurred())
		})

		It("returns error if shell command does not exit 0", func() {
			runner.WhenWaitingFor(fake_command_runner.CommandSpec{}, func(*exec.Cmd) error {
				return errors.New("booo")
			})

			step := &containerizer.ShellRunnerStep{Runner: runner, Path: path}
			err := step.Run()
			Expect(err).To(HaveOccurred())
		})
	})

	Context("when a given path does not exist", func() {
		It("does not execute a shell command", func() {
			step := &containerizer.ShellRunnerStep{Runner: runner, Path: "/whatever.sh"}
			step.Run()
			Expect(runner.StartedCommands()).To(HaveLen(0))
		})