Golang execdriver.Command類代碼示例

func (t *TtyConsole) attach(command *execdriver.Command, pipes *execdriver.Pipes) error {
	command.Stdout = t.slave
	command.Stderr = t.slave
	command.Console = t.slave.Name()

	go func() {
		if wb, ok := pipes.Stdout.(interface {
			CloseWriters() error
		}); ok {
			defer wb.CloseWriters()
		}
		io.Copy(pipes.Stdout, t.master)
	}()

	if pipes.Stdin != nil {
		command.Stdin = t.slave
		command.SysProcAttr.Setctty = true

		go func() {
			defer pipes.Stdin.Close()
			io.Copy(t.master, pipes.Stdin)
		}()
	}
	return nil
}

func (d *driver) Run(c *execdriver.Command, startCallback execdriver.StartCallback) (int, error) {
	params := []string{
		"chroot",
		c.Rootfs,
		"/.dockerinit",
		"-driver",
		DriverName,
	}
	params = append(params, c.Entrypoint)
	params = append(params, c.Arguments...)

	var (
		name = params[0]
		arg  = params[1:]
	)
	aname, err := exec.LookPath(name)
	if err != nil {
		aname = name
	}
	c.Path = aname
	c.Args = append([]string{name}, arg...)

	if err := c.Start(); err != nil {
		return -1, err
	}

	if startCallback != nil {
		startCallback(c)
	}

	err = c.Wait()
	return c.GetExitCode(), err
}

func (d *driver) Restore(c *execdriver.Command) error {
	var nspid int
	f, err := os.Open(filepath.Join(d.root, c.ID, "pid"))
	if err != nil {
		return err
	}
	defer d.removeContainerRoot(c.ID)

	if _, err := fmt.Fscanf(f, "%d", &nspid); err != nil {
		f.Close()
		return err
	}
	f.Close()

	if _, err := os.FindProcess(nspid); err != nil {
		return fmt.Errorf("finding existing pid %d %s", nspid, err)
	}
	c.Process = &os.Process{
		Pid: nspid,
	}
	ticker := time.NewTicker(500 * time.Millisecond)
	defer ticker.Stop()

	for _ = range ticker.C {
		if err := syscall.Kill(nspid, 0); err != nil {
			if strings.Contains(err.Error(), "no such process") {
				return nil
			}
			return fmt.Errorf("signal error %s", err)
		}
	}
	return nil
}

func SetTerminal(command *execdriver.Command, pipes *execdriver.Pipes) error {
	var (
		term execdriver.Terminal
		err  error
	)
	if command.Tty {
		term, err = NewTtyConsole(command, pipes)
	} else {
		term, err = NewStdConsole(command, pipes)
	}
	if err != nil {
		return err
	}
	command.Terminal = term
	return nil
}

func (d *driver) Run(c *execdriver.Command, pipes *execdriver.Pipes, startCallback execdriver.StartCallback) (int, error) {
	if err := d.validateCommand(c); err != nil {
		return -1, err
	}
	var (
		term        nsinit.Terminal
		container   = createContainer(c)
		factory     = &dockerCommandFactory{c: c, driver: d}
		stateWriter = &dockerStateWriter{
			callback: startCallback,
			c:        c,
			dsw:      &nsinit.DefaultStateWriter{filepath.Join(d.root, c.ID)},
		}
		ns   = nsinit.NewNsInit(factory, stateWriter)
		args = append([]string{c.Entrypoint}, c.Arguments...)
	)
	if err := d.createContainerRoot(c.ID); err != nil {
		return -1, err
	}
	defer d.removeContainerRoot(c.ID)

	if c.Tty {
		term = &dockerTtyTerm{
			pipes: pipes,
		}
	} else {
		term = &dockerStdTerm{
			pipes: pipes,
		}
	}
	c.Terminal = term
	if err := d.writeContainerFile(container, c.ID); err != nil {
		return -1, err
	}
	return ns.Exec(container, term, args)
}