1
0
Fork 0
mirror of https://github.com/moby/moby.git synced 2022-11-09 12:21:53 -05:00
moby--moby/runtime.go

350 lines
9.2 KiB
Go
Raw Normal View History

2013-01-18 19:13:39 -05:00
package docker
import (
"container/list"
"fmt"
2013-05-14 18:37:35 -04:00
"github.com/dotcloud/docker/utils"
"io"
2013-01-18 19:13:39 -05:00
"io/ioutil"
"log"
2013-01-18 19:13:39 -05:00
"os"
"os/exec"
2013-01-18 19:13:39 -05:00
"path"
"sort"
"strings"
2013-01-18 19:13:39 -05:00
)
type Capabilities struct {
2013-08-19 08:34:30 -04:00
MemoryLimit bool
SwapLimit bool
IPv4ForwardingDisabled bool
}
type Runtime struct {
2013-02-28 14:52:07 -05:00
root string
repository string
containers *list.List
networkManager *NetworkManager
2013-03-21 20:47:23 -04:00
graph *Graph
repositories *TagStore
2013-05-14 18:37:35 -04:00
idIndex *utils.TruncIndex
capabilities *Capabilities
2013-05-14 18:37:35 -04:00
kernelVersion *utils.KernelVersionInfo
autoRestart bool
volumes *Graph
srv *Server
2013-06-05 17:20:19 -04:00
Dns []string
}
var sysInitPath string
func init() {
2013-05-14 18:37:35 -04:00
sysInitPath = utils.SelfPath()
2013-01-18 19:13:39 -05:00
}
func (runtime *Runtime) List() []*Container {
containers := new(History)
for e := runtime.containers.Front(); e != nil; e = e.Next() {
containers.Add(e.Value.(*Container))
}
return *containers
2013-01-18 19:13:39 -05:00
}
func (runtime *Runtime) getContainerElement(id string) *list.Element {
for e := runtime.containers.Front(); e != nil; e = e.Next() {
2013-01-18 19:13:39 -05:00
container := e.Value.(*Container)
2013-06-04 14:00:22 -04:00
if container.ID == id {
2013-01-18 19:13:39 -05:00
return e
}
}
return nil
}
func (runtime *Runtime) Get(name string) *Container {
id, err := runtime.idIndex.Get(name)
if err != nil {
return nil
}
e := runtime.getContainerElement(id)
2013-01-18 19:13:39 -05:00
if e == nil {
return nil
}
return e.Value.(*Container)
}
func (runtime *Runtime) Exists(id string) bool {
return runtime.Get(id) != nil
2013-01-18 19:13:39 -05:00
}
func (runtime *Runtime) containerRoot(id string) string {
return path.Join(runtime.repository, id)
}
func (runtime *Runtime) Load(id string) (*Container, error) {
container := &Container{root: runtime.containerRoot(id)}
if err := container.FromDisk(); err != nil {
return nil, err
}
2013-06-04 14:00:22 -04:00
if container.ID != id {
return container, fmt.Errorf("Container %s is stored at %s", container.ID, id)
}
2013-04-11 12:26:17 -04:00
if container.State.Running {
container.State.Ghost = true
}
if err := runtime.Register(container); err != nil {
2013-01-18 19:13:39 -05:00
return nil, err
}
return container, nil
}
2013-06-04 14:00:22 -04:00
// Register makes a container object usable by the runtime as <container.ID>
func (runtime *Runtime) Register(container *Container) error {
2013-06-04 14:00:22 -04:00
if container.runtime != nil || runtime.Exists(container.ID) {
return fmt.Errorf("Container is already loaded")
}
2013-06-04 14:00:22 -04:00
if err := validateID(container.ID); err != nil {
return err
}
// init the wait lock
container.waitLock = make(chan struct{})
container.runtime = runtime
// Attach to stdout and stderr
2013-05-14 18:37:35 -04:00
container.stderr = utils.NewWriteBroadcaster()
container.stdout = utils.NewWriteBroadcaster()
// Attach to stdin
if container.Config.OpenStdin {
container.stdin, container.stdinPipe = io.Pipe()
} else {
2013-05-14 18:37:35 -04:00
container.stdinPipe = utils.NopWriteCloser(ioutil.Discard) // Silently drop stdin
}
// done
runtime.containers.PushBack(container)
2013-06-04 14:00:22 -04:00
runtime.idIndex.Add(container.ID)
// When we actually restart, Start() do the monitoring.
// However, when we simply 'reattach', we have to restart a monitor
nomonitor := false
// FIXME: if the container is supposed to be running but is not, auto restart it?
// if so, then we need to restart monitor and init a new lock
// If the container is supposed to be running, make sure of it
if container.State.Running {
2013-06-04 14:00:22 -04:00
output, err := exec.Command("lxc-info", "-n", container.ID).CombinedOutput()
2013-06-04 09:51:12 -04:00
if err != nil {
return err
2013-06-04 09:51:12 -04:00
}
if !strings.Contains(string(output), "RUNNING") {
2013-06-04 14:00:22 -04:00
utils.Debugf("Container %s was supposed to be running be is not.", container.ID)
2013-06-04 09:51:12 -04:00
if runtime.autoRestart {
utils.Debugf("Restarting")
container.State.Ghost = false
container.State.setStopped(0)
hostConfig := &HostConfig{}
if err := container.Start(hostConfig); err != nil {
2013-06-04 09:51:12 -04:00
return err
}
nomonitor = true
} else {
utils.Debugf("Marking as stopped")
container.State.setStopped(-127)
if err := container.ToDisk(); err != nil {
return err
}
}
}
}
// If the container is not running or just has been flagged not running
// then close the wait lock chan (will be reset upon start)
if !container.State.Running {
close(container.waitLock)
} else if !nomonitor {
container.allocateNetwork()
go container.monitor()
}
return nil
}
2013-07-11 13:18:28 -04:00
func (runtime *Runtime) LogToDisk(src *utils.WriteBroadcaster, dst, stream string) error {
log, err := os.OpenFile(dst, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0600)
if err != nil {
return err
}
2013-07-11 13:18:28 -04:00
src.AddWriter(log, stream)
return nil
}
func (runtime *Runtime) Destroy(container *Container) error {
if container == nil {
return fmt.Errorf("The given container is <nil>")
}
2013-06-04 14:00:22 -04:00
element := runtime.getContainerElement(container.ID)
2013-01-18 19:13:39 -05:00
if element == nil {
2013-06-04 14:00:22 -04:00
return fmt.Errorf("Container %v not found - maybe it was already destroyed?", container.ID)
2013-01-18 19:13:39 -05:00
}
if err := container.Stop(3); err != nil {
2013-01-18 19:13:39 -05:00
return err
}
if mounted, err := container.Mounted(); err != nil {
return err
} else if mounted {
if err := container.Unmount(); err != nil {
2013-06-04 14:00:22 -04:00
return fmt.Errorf("Unable to unmount container %v: %v", container.ID, err)
}
}
// Deregister the container before removing its directory, to avoid race conditions
2013-06-04 14:00:22 -04:00
runtime.idIndex.Delete(container.ID)
runtime.containers.Remove(element)
if err := os.RemoveAll(container.root); err != nil {
2013-06-04 14:00:22 -04:00
return fmt.Errorf("Unable to remove filesystem for %v: %v", container.ID, err)
2013-01-18 19:13:39 -05:00
}
return nil
}
func (runtime *Runtime) restore() error {
2013-08-16 09:31:50 -04:00
wheel := "-\\|/"
if os.Getenv("DEBUG") == "" {
fmt.Printf("Loading containers: ")
}
dir, err := ioutil.ReadDir(runtime.repository)
2013-01-18 19:13:39 -05:00
if err != nil {
return err
}
2013-08-16 09:31:50 -04:00
for i, v := range dir {
id := v.Name()
container, err := runtime.Load(id)
2013-08-16 09:31:50 -04:00
if i%21 == 0 && os.Getenv("DEBUG") == "" {
fmt.Printf("\b%c", wheel[i%4])
}
2013-01-18 19:13:39 -05:00
if err != nil {
2013-05-14 18:37:35 -04:00
utils.Debugf("Failed to load container %v: %v", id, err)
2013-01-18 19:13:39 -05:00
continue
}
2013-06-04 14:00:22 -04:00
utils.Debugf("Loaded container %v", container.ID)
2013-01-18 19:13:39 -05:00
}
2013-08-16 09:31:50 -04:00
if os.Getenv("DEBUG") == "" {
fmt.Printf("\bdone.\n")
}
2013-01-18 19:13:39 -05:00
return nil
}
func (runtime *Runtime) UpdateCapabilities(quiet bool) {
2013-05-14 18:37:35 -04:00
if cgroupMemoryMountpoint, err := utils.FindCgroupMountpoint("memory"); err != nil {
if !quiet {
log.Printf("WARNING: %s\n", err)
}
} else {
_, err1 := ioutil.ReadFile(path.Join(cgroupMemoryMountpoint, "memory.limit_in_bytes"))
_, err2 := ioutil.ReadFile(path.Join(cgroupMemoryMountpoint, "memory.soft_limit_in_bytes"))
runtime.capabilities.MemoryLimit = err1 == nil && err2 == nil
if !runtime.capabilities.MemoryLimit && !quiet {
log.Printf("WARNING: Your kernel does not support cgroup memory limit.")
}
_, err = ioutil.ReadFile(path.Join(cgroupMemoryMountpoint, "memory.memsw.limit_in_bytes"))
runtime.capabilities.SwapLimit = err == nil
if !runtime.capabilities.SwapLimit && !quiet {
log.Printf("WARNING: Your kernel does not support cgroup swap limit.")
}
}
content, err3 := ioutil.ReadFile("/proc/sys/net/ipv4/ip_forward")
2013-08-19 08:34:30 -04:00
runtime.capabilities.IPv4ForwardingDisabled = err3 != nil || len(content) == 0 || content[0] != '1'
if runtime.capabilities.IPv4ForwardingDisabled && !quiet {
log.Printf("WARNING: IPv4 forwarding is disabled.")
}
}
// FIXME: harmonize with NewGraph()
func NewRuntime(flGraphPath string, autoRestart bool, dns []string) (*Runtime, error) {
runtime, err := NewRuntimeFromDirectory(flGraphPath, autoRestart)
if err != nil {
return nil, err
}
2013-06-05 17:20:19 -04:00
runtime.Dns = dns
2013-05-15 20:40:47 -04:00
if k, err := utils.GetKernelVersion(); err != nil {
log.Printf("WARNING: %s\n", err)
} else {
runtime.kernelVersion = k
2013-05-14 18:37:35 -04:00
if utils.CompareKernelVersion(k, &utils.KernelVersionInfo{Kernel: 3, Major: 8, Minor: 0}) < 0 {
log.Printf("WARNING: You are running linux kernel version %s, which might be unstable running docker. Please upgrade your kernel to 3.8.0.", k.String())
}
}
runtime.UpdateCapabilities(false)
return runtime, nil
2013-01-18 19:13:39 -05:00
}
func NewRuntimeFromDirectory(root string, autoRestart bool) (*Runtime, error) {
runtimeRepo := path.Join(root, "containers")
if err := os.MkdirAll(runtimeRepo, 0700); err != nil && !os.IsExist(err) {
return nil, err
}
2013-03-21 20:47:23 -04:00
g, err := NewGraph(path.Join(root, "graph"))
if err != nil {
return nil, err
}
volumes, err := NewGraph(path.Join(root, "volumes"))
if err != nil {
return nil, err
}
2013-03-21 20:47:23 -04:00
repositories, err := NewTagStore(path.Join(root, "repositories"), g)
if err != nil {
return nil, fmt.Errorf("Couldn't create Tag store: %s", err)
}
if NetworkBridgeIface == "" {
NetworkBridgeIface = DefaultNetworkBridge
}
netManager, err := newNetworkManager(NetworkBridgeIface)
if err != nil {
return nil, err
}
runtime := &Runtime{
2013-02-28 14:52:07 -05:00
root: root,
repository: runtimeRepo,
2013-02-28 14:52:07 -05:00
containers: list.New(),
networkManager: netManager,
graph: g,
repositories: repositories,
2013-05-14 18:37:35 -04:00
idIndex: utils.NewTruncIndex(),
capabilities: &Capabilities{},
autoRestart: autoRestart,
volumes: volumes,
2013-01-18 19:13:39 -05:00
}
if err := runtime.restore(); err != nil {
2013-01-18 19:13:39 -05:00
return nil, err
}
return runtime, nil
2013-01-18 19:13:39 -05:00
}
type History []*Container
func (history *History) Len() int {
return len(*history)
}
func (history *History) Less(i, j int) bool {
containers := *history
return containers[j].When().Before(containers[i].When())
}
func (history *History) Swap(i, j int) {
containers := *history
tmp := containers[i]
containers[i] = containers[j]
containers[j] = tmp
}
func (history *History) Add(container *Container) {
*history = append(*history, container)
sort.Sort(history)
}