// Run executes the program. func (m *Main) Run(args ...string) error { // Create logger. m.logger = log.New(m.Stdout, "", log.LstdFlags) // Parse command line flags. opt, err := m.ParseFlags(args...) if err != nil { return err } // Open listener. ln, err := net.Listen("tcp4", opt.Addr) if err != nil { return err } m.ln = ln // Multiplex listener to store and http api. storeLn, httpLn := server.Mux(ln) // Set up advertised address and default peer set. advertiseAddr := MergeHostPort(opt.Host, opt.Addr) if len(opt.Peers) == 0 { opt.Peers = []string{advertiseAddr} } // Open store if we are not proxying. if err := m.openStore(opt.DataDir, storeLn, advertiseAddr, opt.Peers); err != nil { return fmt.Errorf("Failed to open store: %s", err) } // Notify user that we're proxying if the store wasn't initialized. if m.store == nil { fmt.Fprintln(m.Stderr, "advertised address not in peer set, joining as proxy") } // Create a slice of peers with their HTTP address set instead. httpPeers, err := SetPortSlice(opt.Peers, opt.Addr) if err != nil { return fmt.Errorf("set port slice: %s", err) } // If we have a DNS address, start a DNS server right away, otherwise // wait for the host network to come up and then start a DNS server. if opt.DNSAddr != "" { if err := m.openDNSServer(opt.DNSAddr, opt.Recursors, httpPeers); err != nil { return fmt.Errorf("Failed to start DNS server: %s", err) } m.logger.Printf("discoverd listening for DNS on %s", opt.DNSAddr) } else if opt.WaitNetDNS { go func() { // Wait for the host network. status, err := cluster.WaitForHostStatus(os.Getenv("EXTERNAL_IP"), func(status *host.HostStatus) bool { return status.Network != nil && status.Network.Subnet != "" }) if err != nil { log.Fatal(err) } // Parse network subnet to determine bind address. ip, _, err := net.ParseCIDR(status.Network.Subnet) if err != nil { log.Fatal(err) } addr := net.JoinHostPort(ip.String(), "53") if err := m.openDNSServer(addr, status.Network.Resolvers, httpPeers); err != nil { log.Fatalf("Failed to start DNS server: %s", err) } m.logger.Printf("discoverd listening for DNS on %s", addr) // Notify webhook. if opt.Notify != "" { m.Notify(opt.Notify, "", addr) } }() } if err := m.openHTTPServer(httpLn, opt.Peers); err != nil { return fmt.Errorf("Failed to start HTTP server: %s", err) } // Notify user that the servers are listening. m.logger.Printf("discoverd listening for HTTP on %s", opt.Addr) // FIXME(benbjohnson): Join to cluster. // Wait for leadership. if err := m.waitForLeader(LeaderTimeout); err != nil { return err } // Notify URL that discoverd is running. httpAddr := ln.Addr().String() host, port, _ := net.SplitHostPort(httpAddr) if host == "0.0.0.0" { httpAddr = net.JoinHostPort(os.Getenv("EXTERNAL_IP"), port) } m.Notify(opt.Notify, "http://"+httpAddr, opt.DNSAddr) go discoverd.NewClientWithURL("http://"+httpAddr).AddServiceAndRegister("discoverd", httpAddr) return nil }
// Run executes the program. func (m *Main) Run(args ...string) error { // Create logger. m.logger = log.New(m.Stdout, "", log.LstdFlags) // Parse command line flags. opt, err := m.ParseFlags(args...) if err != nil { return err } // Set up advertised address and default peer set. advertiseAddr := MergeHostPort(opt.Host, opt.Addr) if len(opt.Peers) == 0 { opt.Peers = []string{advertiseAddr} } // Create a slice of peers with their HTTP address set instead. httpPeers, err := SetPortSlice(opt.Peers, opt.Addr) if err != nil { return fmt.Errorf("set port slice: %s", err) } // if there is a discoverd process already running on this // address perform a deployment by starting a proxy DNS server // and shutting down the old discoverd job var deploy *dd.Deployment var shutdownInfo dt.ShutdownInfo target := fmt.Sprintf("http://%s:1111", opt.Host) m.logger.Println("checking for existing discoverd process at", target) if err := discoverd.NewClientWithHTTP(target, &http.Client{}).Ping(); err == nil { m.logger.Println("discoverd responding at", target, "taking over") // update DISCOVERD environment variable so that the default // discoverd client connects to the instance we intend to replace. os.Setenv("DISCOVERD", target) discoverd.DefaultClient = discoverd.NewClient() deploy, err = dd.NewDeployment("discoverd") if err != nil { return err } m.logger.Println("Created deployment") if err := deploy.MarkPerforming(advertiseAddr, 60); err != nil { return err } m.logger.Println("marked", advertiseAddr, "as performing in deployent") addr, resolvers := waitHostDNSConfig() if opt.DNSAddr != "" { addr = opt.DNSAddr } if len(opt.Recursors) > 0 { resolvers = opt.Recursors } m.logger.Println("starting proxy DNS server") if err := m.openDNSServer(addr, resolvers, httpPeers); err != nil { return fmt.Errorf("Failed to start DNS server: %s", err) } m.logger.Printf("discoverd listening for DNS on %s", addr) shutdownInfo, err = discoverd.NewClientWithURL(target).Shutdown() if err != nil { return err } } else { m.logger.Println("failed to contact existing discoverd server, starting up without takeover") } // Open listener. ln, err := net.Listen("tcp4", opt.Addr) if err != nil { return err } m.ln = ln // Multiplex listener to store and http api. storeLn, httpLn := server.Mux(ln) // Open store if we are not proxying. if err := m.openStore(opt.DataDir, storeLn, advertiseAddr, opt.Peers); err != nil { return fmt.Errorf("Failed to open store: %s", err) } // Notify user that we're proxying if the store wasn't initialized. if m.store == nil { fmt.Fprintln(m.Stderr, "advertised address not in peer set, joining as proxy") } // Wait for the store to catchup before switching to local store if we are doing a deployment if m.store != nil && shutdownInfo.LastIndex > 0 { for m.store.LastIndex() < shutdownInfo.LastIndex { m.logger.Println("Waiting for store to catchup, current:", m.store.LastIndex(), "target:", shutdownInfo.LastIndex) time.Sleep(100 * time.Millisecond) } } // If we already started the DNS server as part of a deployment above, // and we have an initialized store, just switch from the proxy store // to the initialized store. // // Else if we have a DNS address, start a DNS server right away. // // Otherwise wait for the host network to come up and then start a DNS // server. if m.dnsServer != nil && m.store != nil { m.dnsServer.SetStore(m.store) } else if opt.DNSAddr != "" { if err := m.openDNSServer(opt.DNSAddr, opt.Recursors, httpPeers); err != nil { return fmt.Errorf("Failed to start DNS server: %s", err) } m.logger.Printf("discoverd listening for DNS on %s", opt.DNSAddr) } else if opt.WaitNetDNS { go func() { addr, resolvers := waitHostDNSConfig() if err := m.openDNSServer(addr, resolvers, httpPeers); err != nil { log.Fatalf("Failed to start DNS server: %s", err) } m.logger.Printf("discoverd listening for DNS on %s", addr) // Notify webhook. if opt.Notify != "" { m.Notify(opt.Notify, "", addr) } }() } if err := m.openHTTPServer(httpLn, opt.Peers); err != nil { return fmt.Errorf("Failed to start HTTP server: %s", err) } if deploy != nil { if err := deploy.MarkDone(advertiseAddr); err != nil { return err } m.logger.Println("marked", advertiseAddr, "as done in deployment") } // Notify user that the servers are listening. m.logger.Printf("discoverd listening for HTTP on %s", opt.Addr) // FIXME(benbjohnson): Join to cluster. // Wait for leadership. if err := m.waitForLeader(LeaderTimeout); err != nil { return err } // Notify URL that discoverd is running. httpAddr := ln.Addr().String() host, port, _ := net.SplitHostPort(httpAddr) if host == "0.0.0.0" { httpAddr = net.JoinHostPort(os.Getenv("EXTERNAL_IP"), port) } m.Notify(opt.Notify, "http://"+httpAddr, opt.DNSAddr) go discoverd.NewClientWithURL("http://"+httpAddr).AddServiceAndRegister("discoverd", httpAddr) return nil }