mirror of
https://github.com/genuinetools/reg.git
synced 2024-08-21 06:10:23 -04:00
145 lines
2.9 KiB
Go
145 lines
2.9 KiB
Go
package exec // import "github.com/docker/docker/daemon/exec"
|
|
|
|
import (
|
|
"runtime"
|
|
"sync"
|
|
|
|
"github.com/containerd/containerd/cio"
|
|
"github.com/docker/docker/container/stream"
|
|
"github.com/docker/docker/pkg/stringid"
|
|
"github.com/sirupsen/logrus"
|
|
)
|
|
|
|
// Config holds the configurations for execs. The Daemon keeps
|
|
// track of both running and finished execs so that they can be
|
|
// examined both during and after completion.
|
|
type Config struct {
|
|
sync.Mutex
|
|
StreamConfig *stream.Config
|
|
ID string
|
|
Running bool
|
|
ExitCode *int
|
|
OpenStdin bool
|
|
OpenStderr bool
|
|
OpenStdout bool
|
|
CanRemove bool
|
|
ContainerID string
|
|
DetachKeys []byte
|
|
Entrypoint string
|
|
Args []string
|
|
Tty bool
|
|
Privileged bool
|
|
User string
|
|
WorkingDir string
|
|
Env []string
|
|
Pid int
|
|
}
|
|
|
|
// NewConfig initializes the a new exec configuration
|
|
func NewConfig() *Config {
|
|
return &Config{
|
|
ID: stringid.GenerateNonCryptoID(),
|
|
StreamConfig: stream.NewConfig(),
|
|
}
|
|
}
|
|
|
|
type rio struct {
|
|
cio.IO
|
|
|
|
sc *stream.Config
|
|
}
|
|
|
|
func (i *rio) Close() error {
|
|
i.IO.Close()
|
|
|
|
return i.sc.CloseStreams()
|
|
}
|
|
|
|
func (i *rio) Wait() {
|
|
i.sc.Wait()
|
|
|
|
i.IO.Wait()
|
|
}
|
|
|
|
// InitializeStdio is called by libcontainerd to connect the stdio.
|
|
func (c *Config) InitializeStdio(iop *cio.DirectIO) (cio.IO, error) {
|
|
c.StreamConfig.CopyToPipe(iop)
|
|
|
|
if c.StreamConfig.Stdin() == nil && !c.Tty && runtime.GOOS == "windows" {
|
|
if iop.Stdin != nil {
|
|
if err := iop.Stdin.Close(); err != nil {
|
|
logrus.Errorf("error closing exec stdin: %+v", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
return &rio{IO: iop, sc: c.StreamConfig}, nil
|
|
}
|
|
|
|
// CloseStreams closes the stdio streams for the exec
|
|
func (c *Config) CloseStreams() error {
|
|
return c.StreamConfig.CloseStreams()
|
|
}
|
|
|
|
// SetExitCode sets the exec config's exit code
|
|
func (c *Config) SetExitCode(code int) {
|
|
c.ExitCode = &code
|
|
}
|
|
|
|
// Store keeps track of the exec configurations.
|
|
type Store struct {
|
|
byID map[string]*Config
|
|
sync.RWMutex
|
|
}
|
|
|
|
// NewStore initializes a new exec store.
|
|
func NewStore() *Store {
|
|
return &Store{
|
|
byID: make(map[string]*Config),
|
|
}
|
|
}
|
|
|
|
// Commands returns the exec configurations in the store.
|
|
func (e *Store) Commands() map[string]*Config {
|
|
e.RLock()
|
|
byID := make(map[string]*Config, len(e.byID))
|
|
for id, config := range e.byID {
|
|
byID[id] = config
|
|
}
|
|
e.RUnlock()
|
|
return byID
|
|
}
|
|
|
|
// Add adds a new exec configuration to the store.
|
|
func (e *Store) Add(id string, Config *Config) {
|
|
e.Lock()
|
|
e.byID[id] = Config
|
|
e.Unlock()
|
|
}
|
|
|
|
// Get returns an exec configuration by its id.
|
|
func (e *Store) Get(id string) *Config {
|
|
e.RLock()
|
|
res := e.byID[id]
|
|
e.RUnlock()
|
|
return res
|
|
}
|
|
|
|
// Delete removes an exec configuration from the store.
|
|
func (e *Store) Delete(id string, pid int) {
|
|
e.Lock()
|
|
delete(e.byID, id)
|
|
e.Unlock()
|
|
}
|
|
|
|
// List returns the list of exec ids in the store.
|
|
func (e *Store) List() []string {
|
|
var IDs []string
|
|
e.RLock()
|
|
for id := range e.byID {
|
|
IDs = append(IDs, id)
|
|
}
|
|
e.RUnlock()
|
|
return IDs
|
|
}
|