func TestAllocatePortDetection(t *testing.T) { eng := engine.New() eng.Logging = false freePort := findFreePort(t) // Init driver job := eng.Job("initdriver") if res := InitDriver(job); res != engine.StatusOK { t.Fatal("Failed to initialize network driver") } // Allocate interface job = eng.Job("allocate_interface", "container_id") if res := Allocate(job); res != engine.StatusOK { t.Fatal("Failed to allocate network interface") } // Allocate same port twice, expect failure on second call job = newPortAllocationJob(eng, freePort) if res := AllocatePort(job); res != engine.StatusOK { t.Fatal("Failed to find a free port to allocate") } if res := AllocatePort(job); res == engine.StatusOK { t.Fatal("Duplicate port allocation granted by AllocatePort") } }
func TestGetContainersByName(t *testing.T) { eng := engine.New() name := "container_name" var called bool eng.Register("container_inspect", func(job *engine.Job) engine.Status { called = true if job.Args[0] != name { t.Errorf("name != '%s': %#v", name, job.Args[0]) } if api.APIVERSION.LessThan("1.12") && !job.GetenvBool("dirty") { t.Errorf("dirty env variable not set") } else if api.APIVERSION.GreaterThanOrEqualTo("1.12") && job.GetenvBool("dirty") { t.Errorf("dirty env variable set when it shouldn't") } v := &engine.Env{} v.SetBool("dirty", true) if _, err := v.WriteTo(job.Stdout); err != nil { return job.Error(err) } return engine.StatusOK }) r := serveRequest("GET", "/containers/"+name+"/json", nil, eng, t) if !called { t.Fatal("handler was not called") } assertContentType(r, "application/json", t) var stdoutJson interface{} if err := json.Unmarshal(r.Body.Bytes(), &stdoutJson); err != nil { t.Fatalf("%#v", err) } if stdoutJson.(map[string]interface{})["dirty"].(float64) != 1 { t.Fatalf("%#v", stdoutJson) } }
// Spawn starts a new Engine in a child process and returns // a proxy Engine through which it can be controlled. // // The commands available on the child engine are determined // by an earlier call to Init. It is important that Init be // called at the very beginning of the current program - this // allows it to be called as a re-execution hook in the child // process. // // Long story short, if you want to expose `myservice` in a child // process, do this: // // func main() { // spawn.Init(myservice) // [..] // child, err := spawn.Spawn() // [..] // child.Job("dosomething").Run() // } func Spawn() (*engine.Engine, error) { if !initCalled { return nil, fmt.Errorf("spawn.Init must be called at the top of the main() function") } cmd := exec.Command(utils.SelfPath()) cmd.Env = append(cmd.Env, "ENGINESPAWN=1") local, remote, err := beam.SocketPair() if err != nil { return nil, err } child, err := beam.FileConn(local) if err != nil { local.Close() remote.Close() return nil, err } local.Close() cmd.ExtraFiles = append(cmd.ExtraFiles, remote) // FIXME: the beam/engine glue has no way to inform the caller // of the child's termination. The next call will simply return // an error. if err := cmd.Start(); err != nil { child.Close() return nil, err } eng := engine.New() if err := engine.NewSender(child).Install(eng); err != nil { child.Close() return nil, err } return eng, nil }
func TestGetImagesJSON(t *testing.T) { eng := engine.New() var called bool eng.Register("images", func(job *engine.Job) engine.Status { called = true v := createEnvFromGetImagesJSONStruct(sampleImage) if _, err := v.WriteTo(job.Stdout); err != nil { return job.Error(err) } return engine.StatusOK }) r := serveRequest("GET", "/images/json", nil, eng, t) if !called { t.Fatal("handler was not called") } assertHttpNotError(r, t) assertContentType(r, "application/json", t) var observed getImagesJSONStruct if err := json.Unmarshal(r.Body.Bytes(), &observed); err != nil { t.Fatal(err) } if !reflect.DeepEqual(observed, sampleImage) { t.Errorf("Expected %#v but got %#v", sampleImage, observed) } }
func TestGetInfo(t *testing.T) { eng := engine.New() var called bool eng.Register("info", func(job *engine.Job) engine.Status { called = true v := &engine.Env{} v.SetInt("Containers", 1) v.SetInt("Images", 42000) if _, err := v.WriteTo(job.Stdout); err != nil { return job.Error(err) } return engine.StatusOK }) r := serveRequest("GET", "/info", nil, eng, t) if !called { t.Fatalf("handler was not called") } v := readEnv(r.Body, t) if v.GetInt("Images") != 42000 { t.Fatalf("%#v\n", v) } if v.GetInt("Containers") != 1 { t.Fatalf("%#v\n", v) } assertContentType(r, "application/json", t) }
func TestGetImagesHistory(t *testing.T) { eng := engine.New() imageName := "docker-test-image" var called bool eng.Register("history", func(job *engine.Job) engine.Status { called = true if len(job.Args) == 0 { t.Fatal("Job arguments is empty") } if job.Args[0] != imageName { t.Fatalf("name != '%s': %#v", imageName, job.Args[0]) } v := &engine.Env{} if _, err := v.WriteTo(job.Stdout); err != nil { return job.Error(err) } return engine.StatusOK }) r := serveRequest("GET", "/images/"+imageName+"/history", nil, eng, t) if !called { t.Fatalf("handler was not called") } if r.Code != http.StatusOK { t.Fatalf("Got status %d, expected %d", r.Code, http.StatusOK) } if r.HeaderMap.Get("Content-Type") != "application/json" { t.Fatalf("%#v\n", r) } }
func TestGetImagesJSONLegacyFormat(t *testing.T) { eng := engine.New() var called bool eng.Register("images", func(job *engine.Job) engine.Status { called = true outsLegacy := engine.NewTable("Created", 0) outsLegacy.Add(createEnvFromGetImagesJSONStruct(sampleImage)) if _, err := outsLegacy.WriteListTo(job.Stdout); err != nil { return job.Error(err) } return engine.StatusOK }) r := serveRequestUsingVersion("GET", "/images/json", "1.6", nil, eng, t) if !called { t.Fatal("handler was not called") } assertHttpNotError(r, t) assertContentType(r, "application/json", t) images := engine.NewTable("Created", 0) if _, err := images.ReadListFrom(r.Body.Bytes()); err != nil { t.Fatal(err) } if images.Len() != 1 { t.Fatalf("Expected 1 image, %d found", images.Len()) } image := images.Data[0] if image.Get("Tag") != "test-tag" { t.Errorf("Expected tag 'test-tag', found '%s'", image.Get("Tag")) } if image.Get("Repository") != "test-name" { t.Errorf("Expected repository 'test-name', found '%s'", image.Get("Repository")) } }
func TestLogsNoStreams(t *testing.T) { eng := engine.New() var inspect bool var logs bool eng.Register("container_inspect", func(job *engine.Job) engine.Status { inspect = true if len(job.Args) == 0 { t.Fatal("Job arguments is empty") } if job.Args[0] != "test" { t.Fatalf("Container name %s, must be test", job.Args[0]) } return engine.StatusOK }) eng.Register("logs", func(job *engine.Job) engine.Status { logs = true return engine.StatusOK }) r := serveRequest("GET", "/containers/test/logs", nil, eng, t) if r.Code != http.StatusBadRequest { t.Fatalf("Got status %d, expected %d", r.Code, http.StatusBadRequest) } if inspect { t.Fatal("container_inspect job was called, but it shouldn't") } if logs { t.Fatal("logs job was called, but it shouldn't") } res := strings.TrimSpace(r.Body.String()) expected := "Bad parameters: you must choose at least one stream" if !strings.Contains(res, expected) { t.Fatalf("Output %s, expected %s in it", res, expected) } }
func setupBaseImage() { eng, err := engine.New(unitTestStoreBase) if err != nil { log.Fatalf("Can't initialize engine at %s: %s", unitTestStoreBase, err) } job := eng.Job("initserver") job.Setenv("Root", unitTestStoreBase) job.SetenvBool("Autorestart", false) job.Setenv("BridgeIface", unitTestNetworkBridge) if err := job.Run(); err != nil { log.Fatalf("Unable to create a runtime for tests: %s", err) } job = eng.Job("inspect", unitTestImageName, "image") img, _ := job.Stdout.AddEnv() // If the unit test is not found, try to download it. if err := job.Run(); err != nil || img.Get("id") != unitTestImageID { // Retrieve the Image job = eng.Job("pull", unitTestImageName) job.Stdout.Add(utils.NopWriteCloser(os.Stdout)) if err := job.Run(); err != nil { log.Fatalf("Unable to pull the test image: %s", err) } } }
func TestGetVersion(t *testing.T) { eng := engine.New() var called bool eng.Register("version", func(job *engine.Job) engine.Status { called = true v := &engine.Env{} v.SetJson("Version", "42.1") v.Set("ApiVersion", "1.1.1.1.1") v.Set("GoVersion", "2.42") v.Set("Os", "Linux") v.Set("Arch", "x86_64") if _, err := v.WriteTo(job.Stdout); err != nil { return job.Error(err) } return engine.StatusOK }) r := serveRequest("GET", "/version", nil, eng, t) if !called { t.Fatalf("handler was not called") } v := readEnv(r.Body, t) if v.Get("Version") != "42.1" { t.Fatalf("%#v\n", v) } if r.HeaderMap.Get("Content-Type") != "application/json" { t.Fatalf("%#v\n", r) } }
func newTestEngine(t utils.Fataler, autorestart bool, root string) *engine.Engine { if root == "" { if dir, err := newTestDirectory(unitTestStoreBase); err != nil { t.Fatal(err) } else { root = dir } } os.MkdirAll(root, 0700) eng := engine.New() // Load default plugins builtins.Register(eng) // (This is manually copied and modified from main() until we have a more generic plugin system) job := eng.Job("initserver") job.Setenv("Root", root) job.SetenvBool("AutoRestart", autorestart) job.Setenv("ExecDriver", "native") // TestGetEnabledCors and TestOptionsRoute require EnableCors=true job.SetenvBool("EnableCors", true) if err := job.Run(); err != nil { t.Fatal(err) } return eng }
func main() { eng := engine.New() c, err := net.Dial("unix", "beam.sock") if err != nil { fmt.Fprintf(os.Stderr, "%v\n", err) return } defer c.Close() f, err := c.(*net.UnixConn).File() if err != nil { fmt.Fprintf(os.Stderr, "%v\n", err) return } child, err := beam.FileConn(f) if err != nil { fmt.Fprintf(os.Stderr, "%v\n", err) return } defer child.Close() sender := engine.NewSender(child) sender.Install(eng) cmd := eng.Job(os.Args[1], os.Args[2:]...) cmd.Stdout.Add(os.Stdout) cmd.Stderr.Add(os.Stderr) if err := cmd.Run(); err != nil { fmt.Fprintf(os.Stderr, "%v\n", err) os.Exit(1) } }
func TestRestartKillWait(t *testing.T) { eng := NewTestEngine(t) srv := mkServerFromEngine(eng, t) runtime := mkRuntimeFromEngine(eng, t) defer runtime.Nuke() config, hostConfig, _, err := docker.ParseRun([]string{"-i", unitTestImageID, "/bin/cat"}, nil) if err != nil { t.Fatal(err) } id := createTestContainer(eng, config, t) if c := srv.Containers(true, false, -1, "", ""); len(c) != 1 { t.Errorf("Expected 1 container, %v found", len(c)) } job := eng.Job("start", id) if err := job.ImportEnv(hostConfig); err != nil { t.Fatal(err) } if err := job.Run(); err != nil { t.Fatal(err) } job = eng.Job("kill", id) if err := job.Run(); err != nil { t.Fatal(err) } eng, err = engine.New(eng.Root()) if err != nil { t.Fatal(err) } job = eng.Job("initapi") job.Setenv("Root", eng.Root()) job.SetenvBool("AutoRestart", false) // TestGetEnabledCors and TestOptionsRoute require EnableCors=true job.SetenvBool("EnableCors", true) if err := job.Run(); err != nil { t.Fatal(err) } srv = mkServerFromEngine(eng, t) c := srv.Containers(true, false, -1, "", "") if len(c) != 1 { t.Errorf("Expected 1 container, %v found", len(c)) } setTimeout(t, "Waiting on stopped container timedout", 5*time.Second, func() { job = srv.Eng.Job("wait", c[0].ID) var statusStr string job.Stdout.AddString(&statusStr) if err := job.Run(); err != nil { t.Fatal(err) } }) }
func TestLogs(t *testing.T) { eng := engine.New() var inspect bool var logs bool eng.Register("container_inspect", func(job *engine.Job) engine.Status { inspect = true if len(job.Args) == 0 { t.Fatal("Job arguments is empty") } if job.Args[0] != "test" { t.Fatalf("Container name %s, must be test", job.Args[0]) } return engine.StatusOK }) expected := "logs" eng.Register("logs", func(job *engine.Job) engine.Status { logs = true if len(job.Args) == 0 { t.Fatal("Job arguments is empty") } if job.Args[0] != "test" { t.Fatalf("Container name %s, must be test", job.Args[0]) } follow := job.Getenv("follow") if follow != "1" { t.Fatalf("follow: %s, must be 1", follow) } stdout := job.Getenv("stdout") if stdout != "1" { t.Fatalf("stdout %s, must be 1", stdout) } stderr := job.Getenv("stderr") if stderr != "" { t.Fatalf("stderr %s, must be empty", stderr) } timestamps := job.Getenv("timestamps") if timestamps != "1" { t.Fatalf("timestamps %s, must be 1", timestamps) } job.Stdout.Write([]byte(expected)) return engine.StatusOK }) r := serveRequest("GET", "/containers/test/logs?follow=1&stdout=1×tamps=1", nil, eng, t) if r.Code != http.StatusOK { t.Fatalf("Got status %d, expected %d", r.Code, http.StatusOK) } if !inspect { t.Fatal("container_inspect job was not called") } if !logs { t.Fatal("logs job was not called") } res := r.Body.String() if res != expected { t.Fatalf("Output %s, expected %s", res, expected) } }
func TestGetVersion(t *testing.T) { tmp, err := utils.TestDirectory("") if err != nil { t.Fatal(err) } defer os.RemoveAll(tmp) eng, err := engine.New(tmp) if err != nil { t.Fatal(err) } var called bool eng.Register("version", func(job *engine.Job) engine.Status { called = true v := &engine.Env{} v.SetJson("Version", "42.1") v.Set("ApiVersion", "1.1.1.1.1") v.Set("GoVersion", "2.42") v.Set("Os", "Linux") v.Set("Arch", "x86_64") if _, err := v.WriteTo(job.Stdout); err != nil { return job.Error(err) } return engine.StatusOK }) r := httptest.NewRecorder() req, err := http.NewRequest("GET", "/version", nil) if err != nil { t.Fatal(err) } // FIXME getting the version should require an actual running Server if err := ServeRequest(eng, api.APIVERSION, r, req); err != nil { t.Fatal(err) } if !called { t.Fatalf("handler was not called") } out := engine.NewOutput() v, err := out.AddEnv() if err != nil { t.Fatal(err) } if _, err := io.Copy(out, r.Body); err != nil { t.Fatal(err) } out.Close() expected := "42.1" if result := v.Get("Version"); result != expected { t.Errorf("Expected version %s, %s found", expected, result) } expected = "application/json" if result := r.HeaderMap.Get("Content-Type"); result != expected { t.Errorf("Expected Content-Type %s, %s found", expected, result) } }
func tmpEngine(t *testing.T) *engine.Engine { tmp, err := utils.TestDirectory("") if err != nil { t.Fatal(err) } eng, err := engine.New(tmp) if err != nil { t.Fatal(err) } return eng }
func TestGetImagesJSONAll(t *testing.T) { eng := engine.New() allFilter := "-1" eng.Register("images", func(job *engine.Job) engine.Status { allFilter = job.Getenv("all") return engine.StatusOK }) serveRequest("GET", "/images/json?all=1", nil, eng, t) if allFilter != "1" { t.Errorf("%#v", allFilter) } }
func TestGetImagesJSONFilters(t *testing.T) { eng := engine.New() filter := "nothing" eng.Register("images", func(job *engine.Job) engine.Status { filter = job.Getenv("filters") return engine.StatusOK }) serveRequest("GET", "/images/json?filters=nnnn", nil, eng, t) if filter != "nnnn" { t.Errorf("%#v", filter) } }
func NewTestEngine(t utils.Fataler) *engine.Engine { root, err := newTestDirectory(unitTestStoreBase) if err != nil { t.Fatal(err) } eng, err := engine.New(root) if err != nil { t.Fatal(err) } // Load default plugins // (This is manually copied and modified from main() until we have a more generic plugin system) job := eng.Job("initapi") job.Setenv("Root", root) job.SetenvBool("AutoRestart", false) if err := job.Run(); err != nil { t.Fatal(err) } return eng }
func TestGetEvents(t *testing.T) { eng := engine.New() var called bool eng.Register("events", func(job *engine.Job) engine.Status { called = true since := job.Getenv("since") if since != "1" { t.Fatalf("'since' should be 1, found %#v instead", since) } until := job.Getenv("until") if until != "0" { t.Fatalf("'until' should be 0, found %#v instead", until) } v := &engine.Env{} v.Set("since", since) v.Set("until", until) if _, err := v.WriteTo(job.Stdout); err != nil { return job.Error(err) } return engine.StatusOK }) r := serveRequest("GET", "/events?since=1&until=0", nil, eng, t) if !called { t.Fatal("handler was not called") } if r.HeaderMap.Get("Content-Type") != "application/json" { t.Fatalf("%#v\n", r) } var stdout_json struct { Since int Until int } if err := json.Unmarshal(r.Body.Bytes(), &stdout_json); err != nil { t.Fatalf("%#v", err) } if stdout_json.Since != 1 { t.Fatalf("since != 1: %#v", stdout_json.Since) } if stdout_json.Until != 0 { t.Fatalf("until != 0: %#v", stdout_json.Until) } }
func TestAllocatePortReclaim(t *testing.T) { eng := engine.New() eng.Logging = false freePort := findFreePort(t) // Init driver job := eng.Job("initdriver") if res := InitDriver(job); res != engine.StatusOK { t.Fatal("Failed to initialize network driver") } // Allocate interface job = eng.Job("allocate_interface", "container_id") if res := Allocate(job); res != engine.StatusOK { t.Fatal("Failed to allocate network interface") } // Occupy port listenAddr := fmt.Sprintf(":%d", freePort) tcpListenAddr, err := net.ResolveTCPAddr("tcp", listenAddr) if err != nil { t.Fatalf("Failed to resolve TCP address '%s'", listenAddr) } l, err := net.ListenTCP("tcp", tcpListenAddr) if err != nil { t.Fatalf("Fail to listen on port %d", freePort) } // Allocate port, expect failure job = newPortAllocationJob(eng, freePort) if res := AllocatePort(job); res == engine.StatusOK { t.Fatal("Successfully allocated currently used port") } // Reclaim port, retry allocation l.Close() if res := AllocatePort(job); res != engine.StatusOK { t.Fatal("Failed to allocate previously reclaimed port") } }
func NewTestEngine(t utils.Fataler) *engine.Engine { root, err := newTestDirectory(unitTestStoreBase) if err != nil { t.Fatal(err) } eng, err := engine.New(root) if err != nil { t.Fatal(err) } // Load default plugins // (This is manually copied and modified from main() until we have a more generic plugin system) job := eng.Job("initserver") job.Setenv("Root", root) job.SetenvBool("AutoRestart", false) // TestGetEnabledCors and TestOptionsRoute require EnableCors=true job.SetenvBool("EnableCors", true) if err := job.Run(); err != nil { t.Fatal(err) } return eng }
func setupBaseImage() { eng, err := engine.New(unitTestStoreBase) if err != nil { log.Fatalf("Can't initialize engine at %s: %s", unitTestStoreBase, err) } job := eng.Job("initapi") job.Setenv("Root", unitTestStoreBase) job.SetenvBool("Autorestart", false) job.Setenv("BridgeIface", unitTestNetworkBridge) if err := job.Run(); err != nil { log.Fatalf("Unable to create a runtime for tests: %s", err) } srv := mkServerFromEngine(eng, log.New(os.Stderr, "", 0)) // If the unit test is not found, try to download it. if img, err := srv.ImageInspect(unitTestImageName); err != nil || img.ID != unitTestImageID { // Retrieve the Image if err := srv.ImagePull(unitTestImageName, "", os.Stdout, utils.NewStreamFormatter(false), nil, nil, true); err != nil { log.Fatalf("Unable to pull the test image: %s", err) } } }
// Create a temporary runtime suitable for unit testing. // Call t.Fatal() at the first error. func mkRuntime(f utils.Fataler) *docker.Runtime { root, err := newTestDirectory(unitTestStoreBase) if err != nil { f.Fatal(err) } config := &docker.DaemonConfig{ Root: root, AutoRestart: false, Mtu: docker.GetDefaultNetworkMtu(), } eng, err := engine.New(root) if err != nil { f.Fatal(err) } r, err := docker.NewRuntimeFromDirectory(config, eng) if err != nil { f.Fatal(err) } return r }
func TestDeleteContainers(t *testing.T) { eng := engine.New() name := "foo" var called bool eng.Register("container_delete", func(job *engine.Job) engine.Status { called = true if len(job.Args) == 0 { t.Fatalf("Job arguments is empty") } if job.Args[0] != name { t.Fatalf("name != '%s': %#v", name, job.Args[0]) } return engine.StatusOK }) r := serveRequest("DELETE", "/containers/"+name, nil, eng, t) if !called { t.Fatalf("handler was not called") } if r.Code != http.StatusNoContent { t.Fatalf("Got status %d, expected %d", r.Code, http.StatusNoContent) } }
func TestDeleteContainersWithStopAndKill(t *testing.T) { if api.APIVERSION.LessThan("1.14") { return } eng := engine.New() var called bool eng.Register("container_delete", func(job *engine.Job) engine.Status { called = true return engine.StatusOK }) r := serveRequest("DELETE", "/containers/foo?stop=1&kill=1", nil, eng, t) if r.Code != http.StatusBadRequest { t.Fatalf("Got status %d, expected %d", r.Code, http.StatusBadRequest) } if called { t.Fatalf("container_delete jobs was called, but it shouldn't") } res := strings.TrimSpace(r.Body.String()) expected := "Bad parameters: can't use stop and kill simultaneously" if !strings.Contains(res, expected) { t.Fatalf("Output %s, expected %s in it", res, expected) } }
func main() { if selfPath := utils.SelfPath(); strings.Contains(selfPath, ".dockerinit") { // Running in init mode sysinit.SysInit() return } var ( flVersion = flag.Bool([]string{"v", "-version"}, false, "Print version information and quit") flDaemon = flag.Bool([]string{"d", "-daemon"}, false, "Enable daemon mode") flGraphOpts opts.ListOpts flDebug = flag.Bool([]string{"D", "-debug"}, false, "Enable debug mode") flAutoRestart = flag.Bool([]string{"r", "-restart"}, true, "Restart previously running containers") bridgeName = flag.String([]string{"b", "-bridge"}, "", "Attach containers to a pre-existing network bridge\nuse 'none' to disable container networking") bridgeIp = flag.String([]string{"#bip", "-bip"}, "", "Use this CIDR notation address for the network bridge's IP, not compatible with -b") pidfile = flag.String([]string{"p", "-pidfile"}, "/var/run/docker.pid", "Path to use for daemon PID file") flRoot = flag.String([]string{"g", "-graph"}, "/var/lib/docker", "Path to use as the root of the Docker runtime") flSocketGroup = flag.String([]string{"G", "-group"}, "docker", "Group to assign the unix socket specified by -H when running in daemon mode\nuse '' (the empty string) to disable setting of a group") flEnableCors = flag.Bool([]string{"#api-enable-cors", "-api-enable-cors"}, false, "Enable CORS headers in the remote API") flDns = opts.NewListOpts(opts.ValidateIp4Address) flDnsSearch = opts.NewListOpts(opts.ValidateDomain) flEnableIptables = flag.Bool([]string{"#iptables", "-iptables"}, true, "Enable Docker's addition of iptables rules") flEnableIpForward = flag.Bool([]string{"#ip-forward", "-ip-forward"}, true, "Enable net.ipv4.ip_forward") flDefaultIp = flag.String([]string{"#ip", "-ip"}, "0.0.0.0", "Default IP address to use when binding container ports") flInterContainerComm = flag.Bool([]string{"#icc", "-icc"}, true, "Enable inter-container communication") flGraphDriver = flag.String([]string{"s", "-storage-driver"}, "", "Force the Docker runtime to use a specific storage driver") flExecDriver = flag.String([]string{"e", "-exec-driver"}, "native", "Force the Docker runtime to use a specific exec driver") flHosts = opts.NewListOpts(api.ValidateHost) flMtu = flag.Int([]string{"#mtu", "-mtu"}, 0, "Set the containers network MTU\nif no value is provided: default to the default route MTU or 1500 if no default route is available") flTls = flag.Bool([]string{"-tls"}, false, "Use TLS; implied by tls-verify flags") flTlsVerify = flag.Bool([]string{"-tlsverify"}, false, "Use TLS and verify the remote (daemon: verify client, client: verify daemon)") flCa = flag.String([]string{"-tlscacert"}, dockerConfDir+defaultCaFile, "Trust only remotes providing a certificate signed by the CA given here") flCert = flag.String([]string{"-tlscert"}, dockerConfDir+defaultCertFile, "Path to TLS certificate file") flKey = flag.String([]string{"-tlskey"}, dockerConfDir+defaultKeyFile, "Path to TLS key file") flSelinuxEnabled = flag.Bool([]string{"-selinux-enabled"}, false, "Enable selinux support") ) flag.Var(&flDns, []string{"#dns", "-dns"}, "Force Docker to use specific DNS servers") flag.Var(&flDnsSearch, []string{"-dns-search"}, "Force Docker to use specific DNS search domains") flag.Var(&flHosts, []string{"H", "-host"}, "The socket(s) to bind to in daemon mode\nspecified using one or more tcp://host:port, unix:///path/to/socket, fd://* or fd://socketfd.") flag.Var(&flGraphOpts, []string{"-storage-opt"}, "Set storage driver options") flag.Parse() if *flVersion { showVersion() return } if flHosts.Len() == 0 { defaultHost := os.Getenv("DOCKER_HOST") if defaultHost == "" || *flDaemon { // If we do not have a host, default to unix socket defaultHost = fmt.Sprintf("unix://%s", api.DEFAULTUNIXSOCKET) } if _, err := api.ValidateHost(defaultHost); err != nil { log.Fatal(err) } flHosts.Set(defaultHost) } if *bridgeName != "" && *bridgeIp != "" { log.Fatal("You specified -b & --bip, mutually exclusive options. Please specify only one.") } if !*flEnableIptables && !*flInterContainerComm { log.Fatal("You specified --iptables=false with --icc=false. ICC uses iptables to function. Please set --icc or --iptables to true.") } if net.ParseIP(*flDefaultIp) == nil { log.Fatalf("Specified --ip=%s is not in correct format \"0.0.0.0\".", *flDefaultIp) } if *flDebug { os.Setenv("DEBUG", "1") } if *flDaemon { if runtime.GOOS != "linux" { log.Fatalf("The Docker daemon is only supported on linux") } if os.Geteuid() != 0 { log.Fatalf("The Docker daemon needs to be run as root") } if flag.NArg() != 0 { flag.Usage() return } // set up the TempDir to use a canonical path tmp := os.TempDir() realTmp, err := utils.ReadSymlinkedDirectory(tmp) if err != nil { log.Fatalf("Unable to get the full path to the TempDir (%s): %s", tmp, err) } os.Setenv("TMPDIR", realTmp) // get the canonical path to the Docker root directory root := *flRoot var realRoot string if _, err := os.Stat(root); err != nil && os.IsNotExist(err) { realRoot = root } else { realRoot, err = utils.ReadSymlinkedDirectory(root) if err != nil { log.Fatalf("Unable to get the full path to root (%s): %s", root, err) } } if err := checkKernelAndArch(); err != nil { log.Fatal(err) } eng := engine.New() // Load builtins if err := builtins.Register(eng); err != nil { log.Fatal(err) } // load the daemon in the background so we can immediately start // the http api so that connections don't fail while the daemon // is booting go func() { // Load plugin: httpapi job := eng.Job("initserver") job.Setenv("Pidfile", *pidfile) job.Setenv("Root", realRoot) job.SetenvBool("AutoRestart", *flAutoRestart) job.SetenvList("Dns", flDns.GetAll()) job.SetenvList("DnsSearch", flDnsSearch.GetAll()) job.SetenvBool("EnableIptables", *flEnableIptables) job.SetenvBool("EnableIpForward", *flEnableIpForward) job.Setenv("BridgeIface", *bridgeName) job.Setenv("BridgeIP", *bridgeIp) job.Setenv("DefaultIp", *flDefaultIp) job.SetenvBool("InterContainerCommunication", *flInterContainerComm) job.Setenv("GraphDriver", *flGraphDriver) job.SetenvList("GraphOptions", flGraphOpts.GetAll()) job.Setenv("ExecDriver", *flExecDriver) job.SetenvInt("Mtu", *flMtu) job.SetenvBool("EnableSelinuxSupport", *flSelinuxEnabled) job.SetenvList("Sockets", flHosts.GetAll()) if err := job.Run(); err != nil { log.Fatal(err) } // after the daemon is done setting up we can tell the api to start // accepting connections if err := eng.Job("acceptconnections").Run(); err != nil { log.Fatal(err) } }() // TODO actually have a resolved graphdriver to show? log.Printf("docker daemon: %s %s; execdriver: %s; graphdriver: %s", dockerversion.VERSION, dockerversion.GITCOMMIT, *flExecDriver, *flGraphDriver) // Serve api job := eng.Job("serveapi", flHosts.GetAll()...) job.SetenvBool("Logging", true) job.SetenvBool("EnableCors", *flEnableCors) job.Setenv("Version", dockerversion.VERSION) job.Setenv("SocketGroup", *flSocketGroup) job.SetenvBool("Tls", *flTls) job.SetenvBool("TlsVerify", *flTlsVerify) job.Setenv("TlsCa", *flCa) job.Setenv("TlsCert", *flCert) job.Setenv("TlsKey", *flKey) job.SetenvBool("BufferRequests", true) if err := job.Run(); err != nil { log.Fatal(err) } } else { if flHosts.Len() > 1 { log.Fatal("Please specify only one -H") } protoAddrParts := strings.SplitN(flHosts.GetAll()[0], "://", 2) var ( cli *client.DockerCli tlsConfig tls.Config ) tlsConfig.InsecureSkipVerify = true // If we should verify the server, we need to load a trusted ca if *flTlsVerify { *flTls = true certPool := x509.NewCertPool() file, err := ioutil.ReadFile(*flCa) if err != nil { log.Fatalf("Couldn't read ca cert %s: %s", *flCa, err) } certPool.AppendCertsFromPEM(file) tlsConfig.RootCAs = certPool tlsConfig.InsecureSkipVerify = false } // If tls is enabled, try to load and send client certificates if *flTls || *flTlsVerify { _, errCert := os.Stat(*flCert) _, errKey := os.Stat(*flKey) if errCert == nil && errKey == nil { *flTls = true cert, err := tls.LoadX509KeyPair(*flCert, *flKey) if err != nil { log.Fatalf("Couldn't load X509 key pair: %s. Key encrypted?", err) } tlsConfig.Certificates = []tls.Certificate{cert} } } if *flTls || *flTlsVerify { cli = client.NewDockerCli(os.Stdin, os.Stdout, os.Stderr, protoAddrParts[0], protoAddrParts[1], &tlsConfig) } else { cli = client.NewDockerCli(os.Stdin, os.Stdout, os.Stderr, protoAddrParts[0], protoAddrParts[1], nil) } if err := cli.ParseCommands(flag.Args()...); err != nil { if sterr, ok := err.(*utils.StatusError); ok { if sterr.Status != "" { log.Println(sterr.Status) } os.Exit(sterr.StatusCode) } log.Fatal(err) } } }
func TestReloadContainerLinks(t *testing.T) { // FIXME: here we don't use NewTestEngine because it calls initapi with Autorestart=false, // and we want to set it to true. root, err := newTestDirectory(unitTestStoreBase) if err != nil { t.Fatal(err) } eng, err := engine.New(root) if err != nil { t.Fatal(err) } job := eng.Job("initapi") job.Setenv("Root", eng.Root()) job.SetenvBool("Autorestart", true) if err := job.Run(); err != nil { t.Fatal(err) } runtime1 := mkRuntimeFromEngine(eng, t) defer nuke(runtime1) // Create a container with one instance of docker container1, _, _ := mkContainer(runtime1, []string{"-i", "_", "/bin/sh"}, t) defer runtime1.Destroy(container1) // Create a second container meant to be killed container2, _, _ := mkContainer(runtime1, []string{"-i", "_", "/bin/cat"}, t) defer runtime1.Destroy(container2) // Start the container non blocking if err := container2.Start(); err != nil { t.Fatal(err) } // Add a link to container 2 // FIXME @shykes: setting hostConfig.Links seems redundant with calling RegisterLink(). // Why do we need it @crosbymichael? // container1.hostConfig.Links = []string{"/" + container2.ID + ":first"} if err := runtime1.RegisterLink(container1, container2, "first"); err != nil { t.Fatal(err) } if err := container1.Start(); err != nil { t.Fatal(err) } if !container2.State.IsRunning() { t.Fatalf("Container %v should appear as running but isn't", container2.ID) } if !container1.State.IsRunning() { t.Fatalf("Container %s should appear as running but isn't", container1.ID) } if len(runtime1.List()) != 2 { t.Errorf("Expected 2 container, %v found", len(runtime1.List())) } // Here are are simulating a docker restart - that is, reloading all containers // from scratch eng, err = engine.New(root) if err != nil { t.Fatal(err) } job = eng.Job("initapi") job.Setenv("Root", eng.Root()) job.SetenvBool("Autorestart", false) if err := job.Run(); err != nil { t.Fatal(err) } runtime2 := mkRuntimeFromEngine(eng, t) if len(runtime2.List()) != 2 { t.Errorf("Expected 2 container, %v found", len(runtime2.List())) } runningCount := 0 for _, c := range runtime2.List() { if c.State.IsRunning() { runningCount++ } } if runningCount != 2 { t.Fatalf("Expected 2 container alive, %d found", runningCount) } // FIXME: we no longer test if containers were registered in the right order, // because there is no public // Make sure container 2 ( the child of container 1 ) was registered and started first // with the runtime // containers := runtime2.List() if len(containers) == 0 { t.Fatalf("Runtime has no containers") } first := containers[0] if first.ID != container2.ID { t.Fatalf("Container 2 %s should be registered first in the runtime", container2.ID) } // Verify that the link is still registered in the runtime if c := runtime2.Get(container1.Name); c == nil { t.Fatal("Named container is no longer registered after restart") } }
func TestRestore(t *testing.T) { eng := NewTestEngine(t) runtime1 := mkRuntimeFromEngine(eng, t) defer runtime1.Nuke() // Create a container with one instance of docker container1, _, _ := mkContainer(runtime1, []string{"_", "ls", "-al"}, t) defer runtime1.Destroy(container1) // Create a second container meant to be killed container2, _, _ := mkContainer(runtime1, []string{"-i", "_", "/bin/cat"}, t) defer runtime1.Destroy(container2) // Start the container non blocking if err := container2.Start(); err != nil { t.Fatal(err) } if !container2.State.IsRunning() { t.Fatalf("Container %v should appear as running but isn't", container2.ID) } // Simulate a crash/manual quit of dockerd: process dies, states stays 'Running' cStdin, _ := container2.StdinPipe() cStdin.Close() if err := container2.WaitTimeout(2 * time.Second); err != nil { t.Fatal(err) } container2.State.SetRunning(42) container2.ToDisk() if len(runtime1.List()) != 2 { t.Errorf("Expected 2 container, %v found", len(runtime1.List())) } if err := container1.Run(); err != nil { t.Fatal(err) } if !container2.State.IsRunning() { t.Fatalf("Container %v should appear as running but isn't", container2.ID) } // Here are are simulating a docker restart - that is, reloading all containers // from scratch root := eng.Root() eng, err := engine.New(root) if err != nil { t.Fatal(err) } job := eng.Job("initapi") job.Setenv("Root", eng.Root()) job.SetenvBool("Autorestart", false) if err := job.Run(); err != nil { t.Fatal(err) } runtime2 := mkRuntimeFromEngine(eng, t) if len(runtime2.List()) != 2 { t.Errorf("Expected 2 container, %v found", len(runtime2.List())) } runningCount := 0 for _, c := range runtime2.List() { if c.State.IsRunning() { t.Errorf("Running container found: %v (%v)", c.ID, c.Path) runningCount++ } } if runningCount != 0 { t.Fatalf("Expected 0 container alive, %d found", runningCount) } container3 := runtime2.Get(container1.ID) if container3 == nil { t.Fatal("Unable to Get container") } if err := container3.Run(); err != nil { t.Fatal(err) } container2.State.SetStopped(0) }
func main() { if selfPath := utils.SelfPath(); selfPath == "/sbin/init" || selfPath == "/.dockerinit" { // Running in init mode sysinit.SysInit() return } // FIXME: Switch d and D ? (to be more sshd like) flVersion := flag.Bool("v", false, "Print version information and quit") flDaemon := flag.Bool("d", false, "Daemon mode") flDebug := flag.Bool("D", false, "Debug mode") flAutoRestart := flag.Bool("r", true, "Restart previously running containers") bridgeName := flag.String("b", "", "Attach containers to a pre-existing network bridge. Use 'none' to disable container networking") pidfile := flag.String("p", "/var/run/docker.pid", "File containing process PID") flRoot := flag.String("g", "/var/lib/docker", "Path to use as the root of the docker runtime.") flEnableCors := flag.Bool("api-enable-cors", false, "Enable CORS requests in the remote api.") flDns := flag.String("dns", "", "Set custom dns servers") flHosts := utils.ListOpts{fmt.Sprintf("unix://%s", docker.DEFAULTUNIXSOCKET)} flag.Var(&flHosts, "H", "tcp://host:port to bind/connect to or unix://path/to/socket to use") flEnableIptables := flag.Bool("iptables", true, "Disable iptables within docker") flDefaultIp := flag.String("ip", "0.0.0.0", "Default ip address to use when binding a containers ports") flInterContainerComm := flag.Bool("icc", true, "Enable inter-container communication") flag.Parse() if *flVersion { showVersion() return } if len(flHosts) > 1 { flHosts = flHosts[1:] //trick to display a nice default value in the usage } for i, flHost := range flHosts { host, err := utils.ParseHost(docker.DEFAULTHTTPHOST, docker.DEFAULTHTTPPORT, flHost) if err == nil { flHosts[i] = host } else { log.Fatal(err) } } if *flDebug { os.Setenv("DEBUG", "1") } docker.GITCOMMIT = GITCOMMIT docker.VERSION = VERSION if *flDaemon { if flag.NArg() != 0 { flag.Usage() return } eng, err := engine.New(*flRoot) if err != nil { log.Fatal(err) } // Load plugin: httpapi job := eng.Job("initapi") job.Setenv("Pidfile", *pidfile) job.Setenv("Root", *flRoot) job.SetenvBool("AutoRestart", *flAutoRestart) job.SetenvBool("EnableCors", *flEnableCors) job.Setenv("Dns", *flDns) job.SetenvBool("EnableIptables", *flEnableIptables) job.Setenv("BridgeIface", *bridgeName) job.Setenv("DefaultIp", *flDefaultIp) job.SetenvBool("InterContainerCommunication", *flInterContainerComm) if err := job.Run(); err != nil { log.Fatal(err) } // Serve api job = eng.Job("serveapi", flHosts...) job.SetenvBool("Logging", true) if err := job.Run(); err != nil { log.Fatal(err) } } else { if len(flHosts) > 1 { log.Fatal("Please specify only one -H") } protoAddrParts := strings.SplitN(flHosts[0], "://", 2) if err := docker.ParseCommands(protoAddrParts[0], protoAddrParts[1], flag.Args()...); err != nil { if sterr, ok := err.(*utils.StatusError); ok { os.Exit(sterr.Status) } log.Fatal(err) } } }