kotovalexarian-likes-github/moby--moby
1
0
Fork 0
mirror of https://github.com/moby/moby.git synced 2022-11-09 12:21:53 -05:00
Code Releases Activity

Make exec driver run a blocking command

Browse source 
Docker-DCO-1.1-Signed-off-by: Michael Crosby <michael@crosbymichael.com> (github: crosbymichael)
This commit is contained in:
Michael Crosby 2014-01-13 15:02:12 -08:00
parent 92e6db7beb
commit f846ecdc77
5 changed files with 82 additions and 53 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

69
container.go
View file

@ -308,10 +308,10 @@ func (container *Container) generateLXCConfig() error {
return LxcTemplateCompiled.Execute(fo, container)
}
func (container *Container) startPty() error {
func (container *Container) startPty(startCallback execdriver.StartCallback) (int, error) {
ptyMaster, ptySlave, err := pty.Open()
if err != nil {
return err
return -1, err
}
container.ptyMaster = ptyMaster
container.process.Stdout = ptySlave
@ -336,20 +336,17 @@ func (container *Container) startPty() error {
utils.Debugf("startPty: end of stdin pipe")
}()
}
if err := container.runtime.Start(container); err != nil {
return err
}
ptySlave.Close()
return nil
return container.runtime.Run(container, startCallback)
}
func (container *Container) start() error {
func (container *Container) start(startCallback execdriver.StartCallback) (int, error) {
container.process.Stdout = container.stdout
container.process.Stderr = container.stderr
if container.Config.OpenStdin {
stdin, err := container.process.StdinPipe()
if err != nil {
return err
return -1, err
}
go func() {
defer stdin.Close()
@ -358,7 +355,7 @@ func (container *Container) start() error {
utils.Debugf("start: end of stdin pipe")
}()
}
return container.runtime.Start(container)
return container.runtime.Run(container, startCallback)
}
func (container *Container) Attach(stdin io.ReadCloser, stdinCloser io.Closer, stdout io.Writer, stderr io.Writer) chan error {
@ -689,7 +686,6 @@ func (container *Container) Start() (err error) {
Network: en,
Tty: container.Config.Tty,
User: container.Config.User,
WaitLock: make(chan struct{}),
SysInitPath: runtime.sysInitPath,
}
container.process.SysProcAttr = &syscall.SysProcAttr{Setsid: true}
@ -703,21 +699,26 @@ func (container *Container) Start() (err error) {
}
container.waitLock = make(chan struct{})
container.State.SetRunning(0)
go container.monitor()
if container.Config.Tty {
err = container.startPty()
} else {
err = container.start()
}
if err != nil {
return err
waitLock := make(chan struct{})
f := func(process *execdriver.Process) {
container.State.SetRunning(process.Pid())
if process.Tty {
if c, ok := process.Stdout.(io.Closer); ok {
c.Close()
}
}
if err := container.ToDisk(); err != nil {
utils.Debugf("%s", err)
}
close(waitLock)
}
// TODO: @crosbymichael @creack
// find a way to update this
// container.State.SetRunning(container.process.Pid())
container.ToDisk()
go container.monitor(f)
// Start should not return until the process is actually running
<-waitLock
return nil
}
@ -1091,17 +1092,24 @@ func (container *Container) releaseNetwork() {
container.NetworkSettings = &NetworkSettings{}
}
func (container *Container) monitor() {
// Wait for the program to exit
func (container *Container) monitor(f execdriver.StartCallback) {
var (
err error
exitCode int
)
if container.process == nil {
if err := container.runtime.Wait(container, 0); err != nil {
utils.Debugf("monitor: cmd.Wait reported exit status %s for container %s", err, container.ID)
}
// This happends when you have a GHOST container with lxc
err = container.runtime.Wait(container, 0)
} else {
<-container.process.WaitLock
if container.Config.Tty {
exitCode, err = container.startPty(f)
} else {
exitCode, err = container.start(f)
}
}
if err := container.process.WaitError; err != nil {
if err != nil { //TODO: @crosbymichael @creack report error
// Since non-zero exit status and signal terminations will cause err to be non-nil,
// we have to actually discard it. Still, log it anyway, just in case.
utils.Debugf("monitor: cmd.Wait reported exit status %s for container %s", err, container.ID)
@ -1118,7 +1126,6 @@ func (container *Container) monitor() {
container.stdin, container.stdinPipe = io.Pipe()
}
exitCode := container.process.GetExitCode()
container.State.SetStopped(exitCode)
close(container.waitLock)

20
execdriver/chroot/driver.go
View file

@ -17,7 +17,7 @@ func (d *driver) String() string {
return "chroot"
}
func (d *driver) Start(c *execdriver.Process) error {
func (d *driver) Run(c *execdriver.Process, startCallback execdriver.StartCallback) (int, error) {
params := []string{
"chroot",
c.Rootfs,
@ -40,17 +40,27 @@ func (d *driver) Start(c *execdriver.Process) error {
c.Args = append([]string{name}, arg...)
if err := c.Start(); err != nil {
return err
return -1, err
}
var (
waitErr error
waitLock = make(chan struct{})
)
go func() {
if err := c.Wait(); err != nil {
c.WaitError = err
waitErr = err
}
close(c.WaitLock)
close(waitLock)
}()
return nil
if startCallback != nil {
startCallback(c)
}
<-waitLock
return c.GetExitCode(), waitErr
}
func (d *driver) Kill(p *execdriver.Process, sig int) error {

9
execdriver/driver.go
View file

@ -6,10 +6,13 @@ import (
"time"
)
type StartCallback func(*Process)
type Driver interface {
Start(c *Process) error
Run(c *Process, startCallback StartCallback) (int, error) // Run executes the process and blocks until the process exits and returns the exit code
Kill(c *Process, sig int) error
Wait(id string, duration time.Duration) error // Wait on an out of process option - lxc ghosts
// TODO: @crosbymichael @creack wait should probably return the exit code
Wait(id string, duration time.Duration) error // Wait on an out of process...process - lxc ghosts
Version() string
String() string
}
@ -38,8 +41,6 @@ type Process struct {
Tty bool
Network *Network // if network is nil then networking is disabled
SysInitPath string
WaitLock chan struct{}
WaitError error
}
func (c *Process) Pid() int {

31
execdriver/lxc/driver.go
View file

@ -45,7 +45,7 @@ func (d *driver) String() string {
return "lxc"
}
func (d *driver) Start(c *execdriver.Process) error {
func (d *driver) Run(c *execdriver.Process, startCallback execdriver.StartCallback) (int, error) {
params := []string{
startPath,
"-n", c.ID,
@ -111,21 +111,32 @@ func (d *driver) Start(c *execdriver.Process) error {
c.Args = append([]string{name}, arg...)
if err := c.Start(); err != nil {
return err
return -1, err
}
var (
waitErr error
waitLock = make(chan struct{})
)
go func() {
if err := c.Wait(); err != nil {
c.WaitError = err
waitErr = err
}
close(c.WaitLock)
close(waitLock)
}()
// Poll for running
if err := d.waitForStart(c); err != nil {
return err
// Poll lxc for RUNNING status
if err := d.waitForStart(c, waitLock); err != nil {
return -1, err
}
return nil
if startCallback != nil {
startCallback(c)
}
<-waitLock
return c.GetExitCode(), waitErr
}
func (d *driver) Kill(c *execdriver.Process, sig int) error {
@ -171,7 +182,7 @@ func (d *driver) kill(c *execdriver.Process, sig int) error {
return nil
}
func (d *driver) waitForStart(c *execdriver.Process) error {
func (d *driver) waitForStart(c *execdriver.Process, waitLock chan struct{}) error {
var (
err error
output []byte
@ -182,7 +193,7 @@ func (d *driver) waitForStart(c *execdriver.Process) error {
// the end of this loop
for now := time.Now(); time.Since(now) < 5*time.Second; {
select {
case <-c.WaitLock:
case <-waitLock:
// If the process dies while waiting for it, just return
if c.ProcessState != nil && c.ProcessState.Exited() {
return nil

6
runtime.go
View file

@ -192,7 +192,7 @@ func (runtime *Runtime) Register(container *Container) error {
}
container.waitLock = make(chan struct{})
go container.monitor()
go container.monitor(nil)
}
}
return nil
@ -841,8 +841,8 @@ func (runtime *Runtime) Diff(container *Container) (archive.Archive, error) {
return archive.ExportChanges(cDir, changes)
}
func (runtime *Runtime) Start(c *Container) error {
return runtime.execDriver.Start(c.process)
func (runtime *Runtime) Run(c *Container, startCallback execdriver.StartCallback) (int, error) {
return runtime.execDriver.Run(c.process, startCallback)
}
func (runtime *Runtime) Kill(c *Container, sig int) error {