},
				},
			))
		})

		It("returns the correct PID", func() {
			pid, err := execer.Exec("something", "smthg")
			Expect(pid).To(Equal(12))
			Expect(err).ToNot(HaveOccurred())
		})

		It("sets the correct flags", func() {
			_, err := execer.Exec("something", "smthg")
			Expect(err).ToNot(HaveOccurred())

			cmd := commandRunner.StartedCommands()[0]
			Expect(cmd.SysProcAttr).ToNot(BeNil())
			flags := syscall.CLONE_NEWIPC
			flags = flags | syscall.CLONE_NEWNET
			flags = flags | syscall.CLONE_NEWNS
			flags = flags | syscall.CLONE_NEWUTS
			flags = flags | syscall.CLONE_NEWPID
			Expect(int(cmd.SysProcAttr.Cloneflags) & flags).ToNot(Equal(0))
		})

		Context("when the container is not privileged", func() {
			It("creates a user namespace", func() {
				_, err := execer.Exec("something", "smthg")
				Expect(err).ToNot(HaveOccurred())

				cmd := commandRunner.StartedCommands()[0]
Ejemplo n.º 2
0
				oomNotifier.Unwatch()

				Expect(runner.KilledCommands()).To(HaveLen(0))
			})
		})

		Context("when oom has not already occurred", func() {
			BeforeEach(func() {
				runner.WhenWaitingFor(
					fake_command_runner.CommandSpec{},
					func(cmd *exec.Cmd) error {
						return errors.New("Command got killed")
					})
			})

			It("kills the oom process", func() {
				Expect(oomNotifier.Watch(oNoom)).To(Succeed())

				oomNotifier.Unwatch()

				startedCommands := runner.StartedCommands()
				killedCommands := runner.KilledCommands()

				Expect(startedCommands).To(HaveLen(1))
				Expect(startedCommands).To(Equal(killedCommands))
			})
		})
	})
})
			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))
		})

		It("does not return an error", func() {
			step := &containerizer.ShellRunnerStep{Runner: runner, Path: "/whatever.sh"}
			Expect(step.Run()).To(Succeed())
		})
	})
})