type Daemon struct {  
    repository     string  
    sysInitPath    string  
    containers     *contStore  
    graph          *graph.Graph  
    repositories   *graph.TagStore  
    idIndex        *truncindex.TruncIndex  
    sysInfo        *sysinfo.SysInfo  
    volumes        *graph.Graph  
    eng            *engine.Engine  
    config         *Config  
    containerGraph *graphdb.Database  
    driver         graphdriver.Driver  
    execDriver     execdriver.Driver  
}  

type Engine struct {  
    handlers   map[string]Handler  
    catchall   Handler  
    hack       Hack // data for temporary hackery (see hack.go)  
    id         string  
    Stdout     io.Writer  
    Stderr     io.Writer  
    Stdin      io.Reader  
    Logging    bool  
    tasks      sync.WaitGroup  
    l          sync.RWMutex // lock for shutdown  
    shutdown   bool  
    onShutdown []func() // shutdown handlers  
}  

type Job struct {  
    Eng     *Engine  
    Name    string  
    Args    []string  
    env     *Env  
    Stdout  *Output  
    Stderr  *Output  
    Stdin   *Input  
    handler Handler  
    status  Status  
    end     time.Time  
}  

if reexec.Init() {  
    return  
}  
flag.Parse()  
// FIXME: validate daemon flags here  
  
if *flVersion {  
    showVersion()  
    return  
}  
if *flDebug {  
    os.Setenv("DEBUG", "1")  
}  

if len(flHosts) == 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)  
    }  
    defaultHost, err := api.ValidateHost(defaultHost)  
    if err != nil {  
        log.Fatal(err)  
    }  
    flHosts = append(flHosts, defaultHost)  
}  

if *flDaemon {  
    mainDaemon()  
    return  
}  

func Register(eng *engine.Engine) error {  
    if err := daemon(eng); err != nil {  
        return err  
    }  
    if err := remote(eng); err != nil {  
        return err  
    }  
    if err := events.New().Install(eng); err != nil {  
        return err  
    }  
    if err := eng.Register("version", dockerVersion); err != nil {  
        return err  
    }  
    return registry.NewService().Install(eng)  
}  

func daemon(eng *engine.Engine) error {  
        return eng.Register("init_networkdriver", bridge.InitDriver)  
}  

func remote(eng *engine.Engine) error {  
if err := eng.Register("serveapi", apiserver.ServeApi); err != nil {  
return err  
}  
return eng.Register("acceptconnections", apiserver.AcceptConnections)  
}  

// Install installs events public api in docker engine  
func (e *Events) Install(eng *engine.Engine) error {  
    // Here you should describe public interface  
    jobs := map[string]engine.Handler{  
        "events":            e.Get,  
        "log":               e.Log,  
        "subscribers_count": e.SubscribersCount,  
    }  
    for name, job := range jobs {  
        if err := eng.Register(name, job); err != nil {  
            return err  
        }  
    }  
    return nil  
}  

// Install installs registry capabilities to eng.  
func (s *Service) Install(eng *engine.Engine) error {  
    eng.Register("auth", s.Auth)  
    eng.Register("search", s.Search)  
    return nil  
}  

go func() {  
    d, err := daemon.NewDaemon(daemonCfg, eng)  
    if err != nil {  
        log.Fatal(err)  
    }  
    if err := d.Install(eng); err != nil {  
        log.Fatal(err)  
    }  
  
    b := &builder.BuilderJob{eng, d}  
    b.Install()  
  
    // 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)  
    }  
}()  

// Apply configuration defaults  
if config.Mtu == 0 {  
    // FIXME: GetDefaultNetwork Mtu doesn't need to be public anymore  
    config.Mtu = GetDefaultNetworkMtu()  
}  
// Check for mutually incompatible config options  
if config.BridgeIface != "" && config.BridgeIP != "" {  
    return nil, fmt.Errorf("You specified -b & --bip, mutually exclusive options. Please specify only one.")  
}  
if !config.EnableIptables && !config.InterContainerCommunication {  
    return nil, fmt.Errorf("You specified --iptables=false with --icc=false. 
ICC uses iptables to function. Please set --icc or --iptables to true.")  
}  
// FIXME: DisableNetworkBidge doesn't need to be public anymore  
config.DisableNetwork = config.BridgeIface == DisableNetworkBridge  
  
// Claim the pidfile first, to avoid any and all unexpected race conditions.  
// Some of the init doesn't need a pidfile lock - but let's not try to be smart.  
if config.Pidfile != "" {  
    if err := utils.CreatePidFile(config.Pidfile); err != nil {  
        return nil, err  
        }  
        eng.OnShutdown(func() {  
            // Always release the pidfile last, just in case  
            utils.RemovePidFile(config.Pidfile)  
    })  
}  

// Check that the system is supported and we have sufficient privileges  
// FIXME: return errors instead of calling Fatal  
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 err := checkKernelAndArch(); err != nil {  
    log.Fatalf(err.Error())  
}  

// set up the TempDir to use a canonical path  
tmp, err := utils.TempDir(config.Root)  
if err != nil {  
    log.Fatalf("Unable to get the TempDir under %s: %s", config.Root, err)  
}  
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)  
if !config.EnableSelinuxSupport {  
    selinuxSetDisabled()  
}  
// get the canonical path to the Docker root directory  
var realRoot string  
if _, err := os.Stat(config.Root); err != nil && os.IsNotExist(err) {  
    realRoot = config.Root  
} else {  
    realRoot, err = utils.ReadSymlinkedDirectory(config.Root)  
    if err != nil {  
        log.Fatalf("Unable to get the full path to root (%s): %s", config.Root, err)  
    }  
}  
config.Root = realRoot  
// Create the root directory if it doesn't exists  
if err := os.MkdirAll(config.Root, 0700); err != nil && !os.IsExist(err) {  
    return nil, err  
}  

// Set the default driver  
graphdriver.DefaultDriver = config.GraphDriver  
// Load storage driver  
driver, err := graphdriver.New(config.Root, config.GraphOptions)  
if err != nil {  
    return nil, err  
}  
log.Debugf("Using graph driver %s", driver)  
// As Docker on btrfs and SELinux are incompatible at present, error on both being enabled  
if config.EnableSelinuxSupport && driver.String() == "btrfs" {  
    return nil, fmt.Errorf("SELinux is not supported with the BTRFS graph driver!")  
}  

log.Debugf("Creating images graph")  
g, err := graph.NewGraph(path.Join(config.Root, "graph"), driver)  
if err != nil {  
    return nil, err  
}  
  
// We don't want to use a complex driver like aufs or devmapper  
// for volumes, just a plain filesystem  
volumesDriver, err := graphdriver.GetDriver("vfs", config.Root, config.GraphOptions)  
if err != nil {  
    return nil, err  
}  
log.Debugf("Creating volumes graph")  
volumes, err := graph.NewGraph(path.Join(config.Root, "volumes"), volumesDriver)  
if err != nil {  
    return nil, err  
}  
log.Debugf("Creating repository list")  
repositories, err := graph.NewTagStore(path.Join(config.Root, "repositories-"+driver.String()), g)  
if err != nil {  
    return nil, fmt.Errorf("Couldn't create Tag store: %s", err)  
¡­¡­  
graphdbPath := path.Join(config.Root, "linkgraph.db")  
    graph, err := graphdb.NewSqliteConn(graphdbPath)  
    if err != nil {  
        return nil, err  
}   

localCopy := path.Join(config.Root, "init", fmt.Sprintf("dockerinit-%s", dockerversion.VERSION))  
sysInitPath := utils.DockerInitPath(localCopy)  
if sysInitPath == ""   
    return nil, fmt.Errorf("Could not locate dockerinit: This usually means docker was built incorrectly.
 See http://docs.docker.com/contributing/devenvironment for official build instructions.")  
}  

if err := daemon.checkLocaldns(); err != nil {  
    return nil, err  
} 

if err := daemon.restore(); err != nil {  
    return nil, err  
} 

return daemon, nil  

b := &builder.BuilderJob{eng, d}  
b.Install() 

func (b *BuilderJob) Install() {  
    b.Engine.Register("build", b.CmdBuild)  
} 

// Serve api  
job := eng.Job("serveapi", flHosts...)  
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)  
}