mirror of
https://github.com/moby/moby.git
synced 2022-11-09 12:21:53 -05:00
![Michael Crosby](/assets/img/avatar_default.png)
Add close method to Runtime and Server to make sure that any underlying connections are cleaned up
192 lines
5.2 KiB
Go
192 lines
5.2 KiB
Go
package main
|
|
|
|
import (
|
|
"flag"
|
|
"fmt"
|
|
"github.com/dotcloud/docker"
|
|
"github.com/dotcloud/docker/sysinit"
|
|
"github.com/dotcloud/docker/utils"
|
|
"io/ioutil"
|
|
"log"
|
|
"net"
|
|
"os"
|
|
"os/signal"
|
|
"strconv"
|
|
"strings"
|
|
"syscall"
|
|
)
|
|
|
|
var (
|
|
GITCOMMIT string
|
|
VERSION string
|
|
)
|
|
|
|
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")
|
|
flGraphPath := flag.String("g", "/var/lib/docker", "Path to graph storage base dir.")
|
|
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("enable-container-comm", false, "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)
|
|
}
|
|
}
|
|
|
|
bridge := docker.DefaultNetworkBridge
|
|
if *bridgeName != "" {
|
|
bridge = *bridgeName
|
|
}
|
|
if *flDebug {
|
|
os.Setenv("DEBUG", "1")
|
|
}
|
|
docker.GITCOMMIT = GITCOMMIT
|
|
docker.VERSION = VERSION
|
|
if *flDaemon {
|
|
if flag.NArg() != 0 {
|
|
flag.Usage()
|
|
return
|
|
}
|
|
var dns []string
|
|
if *flDns != "" {
|
|
dns = []string{*flDns}
|
|
}
|
|
|
|
ip := net.ParseIP(*flDefaultIp)
|
|
|
|
config := &docker.DaemonConfig{
|
|
Pidfile: *pidfile,
|
|
GraphPath: *flGraphPath,
|
|
AutoRestart: *flAutoRestart,
|
|
EnableCors: *flEnableCors,
|
|
Dns: dns,
|
|
EnableIptables: *flEnableIptables,
|
|
BridgeIface: bridge,
|
|
ProtoAddresses: flHosts,
|
|
DefaultIp: ip,
|
|
InterContainerCommunication: *flInterContainerComm,
|
|
}
|
|
if err := daemon(config); 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)
|
|
}
|
|
}
|
|
}
|
|
|
|
func showVersion() {
|
|
fmt.Printf("Docker version %s, build %s\n", VERSION, GITCOMMIT)
|
|
}
|
|
|
|
func createPidFile(pidfile string) error {
|
|
if pidString, err := ioutil.ReadFile(pidfile); err == nil {
|
|
pid, err := strconv.Atoi(string(pidString))
|
|
if err == nil {
|
|
if _, err := os.Stat(fmt.Sprintf("/proc/%d/", pid)); err == nil {
|
|
return fmt.Errorf("pid file found, ensure docker is not running or delete %s", pidfile)
|
|
}
|
|
}
|
|
}
|
|
|
|
file, err := os.Create(pidfile)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
defer file.Close()
|
|
|
|
_, err = fmt.Fprintf(file, "%d", os.Getpid())
|
|
return err
|
|
}
|
|
|
|
func removePidFile(pidfile string) {
|
|
if err := os.Remove(pidfile); err != nil {
|
|
log.Printf("Error removing %s: %s", pidfile, err)
|
|
}
|
|
}
|
|
|
|
func daemon(config *docker.DaemonConfig) error {
|
|
if err := createPidFile(config.Pidfile); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
defer removePidFile(config.Pidfile)
|
|
|
|
server, err := docker.NewServer(config)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer server.Close()
|
|
|
|
c := make(chan os.Signal, 1)
|
|
signal.Notify(c, os.Interrupt, os.Kill, os.Signal(syscall.SIGTERM))
|
|
go func() {
|
|
sig := <-c
|
|
log.Printf("Received signal '%v', exiting\n", sig)
|
|
server.Close()
|
|
removePidFile(config.Pidfile)
|
|
os.Exit(0)
|
|
}()
|
|
|
|
chErrors := make(chan error, len(config.ProtoAddresses))
|
|
for _, protoAddr := range config.ProtoAddresses {
|
|
protoAddrParts := strings.SplitN(protoAddr, "://", 2)
|
|
if protoAddrParts[0] == "unix" {
|
|
syscall.Unlink(protoAddrParts[1])
|
|
} else if protoAddrParts[0] == "tcp" {
|
|
if !strings.HasPrefix(protoAddrParts[1], "127.0.0.1") {
|
|
log.Println("/!\\ DON'T BIND ON ANOTHER IP ADDRESS THAN 127.0.0.1 IF YOU DON'T KNOW WHAT YOU'RE DOING /!\\")
|
|
}
|
|
} else {
|
|
server.Close()
|
|
removePidFile(config.Pidfile)
|
|
log.Fatal("Invalid protocol format.")
|
|
}
|
|
go func() {
|
|
chErrors <- docker.ListenAndServe(protoAddrParts[0], protoAddrParts[1], server, true)
|
|
}()
|
|
}
|
|
for i := 0; i < len(config.ProtoAddresses); i += 1 {
|
|
err := <-chErrors
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|