// getRegistry initializes a connection to the Registry func getRegistry() registry.Registry { tun := getTunnelFlag() machines := []string{globalFlags.Endpoint} client := etcd.NewClient(machines) if tun != "" { sshClient, err := ssh.NewSSHClient("core", tun, getChecker(), false) if err != nil { fmt.Fprintf(os.Stderr, "Failed initializing SSH client: %v\n", err) os.Exit(1) } dial := func(network, addr string) (net.Conn, error) { tcpaddr, err := net.ResolveTCPAddr(network, addr) if err != nil { return nil, err } return sshClient.DialTCP(network, nil, tcpaddr) } tr := http.Transport{ Dial: dial, TLSClientConfig: &tls.Config{ InsecureSkipVerify: true, }, } client.SetTransport(&tr) } return registry.New(client, globalFlags.EtcdKeyPrefix) }
func getFleetRegistryClient() (fleetClient.API, error) { var dial func(string, string) (net.Conn, error) tlsConfig, err := fleetPkg.ReadTLSConfigFiles("", "", "") if err != nil { return nil, err } trans := &http.Transport{ Dial: dial, TLSClientConfig: tlsConfig, } timeout := 3 * 1000 * time.Millisecond machines := strings.Split(*argEndpoints, ",") eClient, err := etcd.NewClient(machines, trans, timeout) if err != nil { return nil, err } reg := registry.NewEtcdRegistry(eClient, "/_coreos.com/fleet/") return &fleetClient.RegistryClient{Registry: reg}, nil }
func NewRegistryClient(trans *http.Transport, endpoint, keyPrefix string) (API, error) { machines := []string{endpoint} client, err := etcd.NewClient(machines, *trans) if err != nil { return nil, err } return registry.New(client, keyPrefix), nil }
func NewRegistryClient(trans *http.Transport, endpoint, keyPrefix string, requestTimeout time.Duration) (API, error) { machines := []string{endpoint} client, err := etcd.NewClient(machines, *trans, requestTimeout) if err != nil { return nil, err } return registry.New(client, keyPrefix), nil }
func New(cfg config.Config) (*Server, error) { mach, err := newMachineFromConfig(cfg) if err != nil { return nil, err } mgr, err := systemd.NewSystemdUnitManager(systemd.DefaultUnitsDirectory) if err != nil { return nil, err } eClient, err := etcd.NewClient(cfg.EtcdServers, http.Transport{}) if err != nil { return nil, err } reg := registry.New(eClient, cfg.EtcdKeyPrefix) a, err := newAgentFromConfig(mach, reg, cfg, mgr) if err != nil { return nil, err } e := engine.New(reg, mach) sStream := systemd.NewEventStream(mgr) rStream, err := registry.NewEventStream(eClient, reg) if err != nil { return nil, err } aHandler := agent.NewEventHandler(a) eHandler := engine.NewEventHandler(e) eBus := event.NewEventBus() eBus.AddListener("engine", eHandler) eBus.AddListener("agent", aHandler) listeners, err := activation.Listeners(false) if err != nil { return nil, err } mux := api.NewServeMux(reg) for _, f := range listeners { go http.Serve(f, mux) } return &Server{a, e, rStream, sStream, eBus, mach, nil}, nil }
func getRegistryClient() (client.API, error) { var dial func(string, string) (net.Conn, error) sshTimeout := time.Duration(Flags.SSHTimeout*1000) * time.Millisecond tun := getTunnelFlag() if tun != "" { sshClient, err := ssh.NewSSHClient("core", tun, getChecker(), false, sshTimeout) if err != nil { return nil, fmt.Errorf("failed initializing SSH client: %v", err) } dial = func(network, addr string) (net.Conn, error) { tcpaddr, err := net.ResolveTCPAddr(network, addr) if err != nil { return nil, err } return sshClient.DialTCP(network, nil, tcpaddr) } } tlsConfig, err := pkg.ReadTLSConfigFiles(Flags.EtcdCAFile, Flags.EtcdCertFile, Flags.EtcdKeyFile) if err != nil { return nil, err } trans := &http.Transport{ Dial: dial, TLSClientConfig: tlsConfig, } timeout := time.Duration(Flags.RequestTimeout*1000) * time.Millisecond machines := []string{Flags.Endpoint} eClient, err := etcd.NewClient(machines, trans, timeout) if err != nil { return nil, err } reg := registry.NewEtcdRegistry(eClient, Flags.EtcdKeyPrefix) // if msg, ok := checkVersion(reg); !ok { // stderr(msg) // } return &client.RegistryClient{Registry: reg}, nil }
// GetNodesInCluster return the list of ip address of all the nodes // running in the cluster currently active (fleetctl list-machines) func GetNodesInCluster(url []string) []string { etcdClient, err := etcd.NewClient(url, &http.Transport{}, time.Second) if err != nil { log.Debugf("error creating new fleet etcd client: %v", err) return []string{} } fleetClient := registry.NewEtcdRegistry(etcdClient, "/_coreos.com/fleet/") machines, err := fleetClient.Machines() if err != nil { log.Debugf("error creating new fleet etcd client: %v", err) return []string{} } var machineList []string for _, m := range machines { machineList = append(machineList, m.PublicIP) } return machineList }
func New(cfg config.Config) (*Server, error) { mach, err := newMachineFromConfig(cfg) if err != nil { return nil, err } mgr, err := systemd.NewSystemdUnitManager(systemd.DefaultUnitsDirectory) if err != nil { return nil, err } eClient := etcd.NewClient(cfg.EtcdServers) reg := registry.New(eClient, cfg.EtcdKeyPrefix) a, err := newAgentFromConfig(mach, reg, cfg, mgr) if err != nil { return nil, err } e := engine.New(reg, mach) sStream := systemd.NewEventStream(mgr) rStream, err := registry.NewEventStream(eClient, reg) if err != nil { return nil, err } aHandler := agent.NewEventHandler(a) eHandler := engine.NewEventHandler(e) eBus := event.NewEventBus() eBus.AddListener("engine", eHandler) eBus.AddListener("agent", aHandler) return &Server{a, e, rStream, sStream, eBus, mach, nil}, nil }
// GetNodesWithMetadata returns the ip address of the nodes with all the specified roles func GetNodesWithMetadata(url []string, metadata map[string][]string) ([]string, error) { etcdClient, err := etcd.NewClient(url, &http.Transport{}, time.Second) if err != nil { log.Debugf("error creating new fleet etcd client: %v", err) return nil, err } fleetClient := registry.NewEtcdRegistry(etcdClient, "/_coreos.com/fleet/") machines, err := fleetClient.Machines() if err != nil { log.Debugf("error creating new fleet etcd client: %v", err) return nil, err } var machineList []string for _, m := range machines { if hasMetadata(m, metadata) { machineList = append(machineList, m.PublicIP) } } return machineList, nil }
func getFleetRegistryClient(fleetEndpoints []string) (fleetClient.API, error) { var dial func(string, string) (net.Conn, error) tlsConfig, err := fleetPkg.ReadTLSConfigFiles("", "", "") if err != nil { return nil, err } trans := &http.Transport{ Dial: dial, TLSClientConfig: tlsConfig, } timeout := 3 * time.Second eClient, err := etcd.NewClient(fleetEndpoints, trans, timeout) if err != nil { return nil, err } reg := registry.NewEtcdRegistry(eClient, etcdRegistry) return &fleetClient.RegistryClient{Registry: reg}, nil }
func New(cfg config.Config) (*Server, error) { mgr, err := systemd.NewSystemdUnitManager(systemd.DefaultUnitsDirectory) if err != nil { return nil, err } mach, err := newMachineFromConfig(cfg, mgr) if err != nil { return nil, err } tlsConfig, err := etcd.ReadTLSConfigFiles(cfg.EtcdCAFile, cfg.EtcdCertFile, cfg.EtcdKeyFile) if err != nil { return nil, err } eTrans := http.Transport{TLSClientConfig: tlsConfig} timeout := time.Duration(cfg.EtcdRequestTimeout*1000) * time.Millisecond eClient, err := etcd.NewClient(cfg.EtcdServers, eTrans, timeout) if err != nil { return nil, err } reg := registry.New(eClient, cfg.EtcdKeyPrefix) pub := agent.NewUnitStatePublisher(mgr, reg, mach) gen := unit.NewUnitStateGenerator(mgr) a, err := newAgentFromConfig(mach, reg, cfg, mgr, gen) if err != nil { return nil, err } ar, err := newAgentReconcilerFromConfig(reg, eClient, cfg) if err != nil { return nil, err } e, err := newEngineFromConfig(reg, eClient, mach, cfg) if err != nil { return nil, err } listeners, err := activation.Listeners(false) if err != nil { return nil, err } hrt, mon, err := newHeartMonitorFromConfig(mach, reg, cfg) if err != nil { return nil, err } apiServer := api.NewServer(listeners, api.NewServeMux(reg)) apiServer.Serve() eIval := time.Duration(cfg.EngineReconcileInterval*1000) * time.Millisecond srv := Server{ agent: a, aReconciler: ar, usGen: gen, usPub: pub, engine: e, mach: mach, hrt: hrt, mon: mon, api: apiServer, stop: nil, engineReconcileInterval: eIval, } return &srv, nil }
func New(cfg config.Config) (*Server, error) { etcdRequestTimeout := time.Duration(cfg.EtcdRequestTimeout*1000) * time.Millisecond agentTTL, err := time.ParseDuration(cfg.AgentTTL) if err != nil { return nil, err } mgr, err := systemd.NewSystemdUnitManager(systemd.DefaultUnitsDirectory) if err != nil { return nil, err } mach, err := newMachineFromConfig(cfg, mgr) if err != nil { return nil, err } tlsConfig, err := pkg.ReadTLSConfigFiles(cfg.EtcdCAFile, cfg.EtcdCertFile, cfg.EtcdKeyFile) if err != nil { return nil, err } eTrans := &http.Transport{TLSClientConfig: tlsConfig} eClient, err := etcd.NewClient(cfg.EtcdServers, eTrans, etcdRequestTimeout) if err != nil { return nil, err } reg := registry.NewEtcdRegistry(eClient, cfg.EtcdKeyPrefix) pub := agent.NewUnitStatePublisher(reg, mach, agentTTL) gen := unit.NewUnitStateGenerator(mgr) a := agent.New(mgr, gen, reg, mach, agentTTL) rStream := registry.NewEtcdEventStream(eClient, cfg.EtcdKeyPrefix) ar := agent.NewReconciler(reg, rStream) e := engine.New(reg, rStream, mach) listeners, err := activation.Listeners(false) if err != nil { return nil, err } hrt := heart.New(reg, mach) mon := heart.NewMonitor(agentTTL) apiServer := api.NewServer(listeners, api.NewServeMux(reg)) apiServer.Serve() eIval := time.Duration(cfg.EngineReconcileInterval*1000) * time.Millisecond srv := Server{ agent: a, aReconciler: ar, usGen: gen, usPub: pub, engine: e, mach: mach, hrt: hrt, mon: mon, api: apiServer, stop: nil, engineReconcileInterval: eIval, } return &srv, nil }
func New(cfg config.Config) (*Server, error) { mgr, err := systemd.NewSystemdUnitManager(systemd.DefaultUnitsDirectory) if err != nil { return nil, err } mach, err := newMachineFromConfig(cfg, mgr) if err != nil { return nil, err } tlsConfig, err := etcd.TLSClientConfig(cfg.EtcdCAFile, cfg.EtcdCertFile, cfg.EtcdKeyFile) if err != nil { return nil, err } eClient, err := etcd.NewClient(cfg.EtcdServers, http.Transport{TLSClientConfig: tlsConfig}) if err != nil { return nil, err } reg := registry.New(eClient, cfg.EtcdKeyPrefix) pub := agent.NewUnitStatePublisher(mgr, reg, mach) gen := unit.NewUnitStateGenerator(mgr) a, err := newAgentFromConfig(mach, reg, cfg, mgr, gen) if err != nil { return nil, err } ar, err := newAgentReconcilerFromConfig(reg, cfg) if err != nil { return nil, err } e := engine.New(reg, mach) rStream, err := registry.NewEventStream(eClient, reg) if err != nil { return nil, err } eBus := event.NewEventBus() eBus.AddListener(event.JobEvent, ar.Trigger) eBus.AddListener(event.GlobalEvent, e.Trigger) listeners, err := activation.Listeners(false) if err != nil { return nil, err } hrt, mon, err := newHeartMonitorFromConfig(mach, reg, cfg) if err != nil { return nil, err } apiServer := api.NewServer(listeners, api.NewServeMux(reg)) apiServer.Serve() srv := Server{ agent: a, aReconciler: ar, usGen: gen, usPub: pub, engine: e, rStream: rStream, eBus: eBus, mach: mach, hrt: hrt, mon: mon, api: apiServer, stop: nil, } return &srv, nil }
func VulcanListener(in, out chan Message) { send := Messenger(TopicVulcan, out) etcdClient := etcd.NewClient(strings.Split(config.EtcdHosts, ",")) listenTo := TopicDocker key := "" registered := false var ( timeout uint64 = 10 tick <-chan time.Time ) register := func() (success bool) { ip, err := dockerClient.PublicPort(config.Group+"-"+config.ID, config.PublicPort) if err != nil { send(LevelError, StatusBad, err.Error()) return false } _, err = etcdClient.Set(key, fmt.Sprintf("%s:%d", config.PublicHost, ip), timeout) if err != nil { send(LevelError, StatusBad, err.Error()) return false } return true } deregister := func() (success bool) { _, err := etcdClient.Delete(key, false) if err != nil { send(LevelError, StatusBad, err.Error()) return false } return true } for { select { case message := <-in: switch message.Topic { case TopicInit: if !config.RegisterVulcan { return } if config.PublicPort == 0 { send(LevelError, StatusBad, "cannot register a service on port 0") return } if config.TCPHealthPort != 0 { listenTo = TopicTCPHealth } send(LevelDebug, StatusNeutral, "setting up vulcan") key = fmt.Sprintf("/vulcand/upstreams/%s/endpoints/%s", config.Group, config.ID) tick = time.Tick(time.Duration(timeout/2) * time.Second) case TopicShutdown: deregister() send(LevelChange, StatusDown, "tearing down vulcan") case listenTo: if message.Level != LevelChange { continue } switch message.Status { case StatusUp: if !registered { success := register() if success { registered = true send(LevelChange, StatusUp, fmt.Sprintf("registered %s", key)) } } case StatusDown: if registered { success := deregister() if success { registered = false send(LevelChange, StatusDown, fmt.Sprintf("deregistered %s", key)) } } } } case <-tick: if registered { register() } } } }
func fleetAPI() fleet.API { if *fleetEndpoint == "" { glog.Fatalln("No --fleet-fleetEndpoint provided.") } var fleetClient fleet.API switch *fleetDriver { case "http": ep, err := url.Parse(*fleetEndpoint) if err != nil { glog.Fatal(err) } var trans http.RoundTripper switch ep.Scheme { case "unix", "file": // This commonly happens if the user misses the leading slash after the scheme. // For example, "unix://var/run/fleet.sock" would be parsed as host "var". if len(ep.Host) > 0 { glog.Fatalf("unable to connect to host %q with scheme %q\n", ep.Host, ep.Scheme) } // The Path field is only used for dialing and should not be used when // building any further HTTP requests. sockPath := ep.Path ep.Path = "" // http.Client doesn't support the schemes "unix" or "file", but it // is safe to use "http" as dialFunc ignores it anyway. ep.Scheme = "http" // The Host field is not used for dialing, but will be exposed in debug logs. ep.Host = "domain-sock" trans = &http.Transport{ Dial: func(s, t string) (net.Conn, error) { // http.Client does not natively support dialing a unix domain socket, so the // dial function must be overridden. return net.Dial("unix", sockPath) }, } case "http", "https": trans = http.DefaultTransport default: glog.Fatalf("Unknown scheme in fleet fleetEndpoint: %s\n", ep.Scheme) } c := &http.Client{ Transport: trans, } fleetClient, err = fleet.NewHTTPClient(c, *ep) if err != nil { glog.Fatalf("Failed to create FleetHttpClient: %s\n", err) } case "etcd": // Code vaguely oriented on fleetctls getRegistryClient() // https://github.com/coreos/fleet/blob/2e21d3bfd5959a70513c5e0d3c2500dc3c0811cf/fleetctl/fleetctl.go#L312 timeout := time.Duration(5 * time.Second) machines := strings.Split(*fleetEndpoint, ",") trans := &http.Transport{} eClient, err := etcd.NewClient(machines, trans, timeout) if err != nil { glog.Fatalln("Failed to build etcd client: " + err.Error()) } reg := registry.NewEtcdRegistry(eClient, registry.DefaultKeyPrefix) fleetClient = &fleet.RegistryClient{reg} default: glog.Fatalf("Unknown fleet driver: %s\n", *fleetDriver) } glog.Infof("using fleet driver: %s with fleetEndpoint: %s", *fleetDriver, *fleetEndpoint) return fleetClient }