// 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
}