// Opens a connection to the master if not already connected
func (a *api) connectMaster() (*master.Client, error) {
if a.master == nil {
var err error
a.master, err = master.NewClient(options.Endpoint)
if err != nil {
return nil, fmt.Errorf("could not create a client to the master: %s", err)
}
}
return a.master, nil
}
func (d *daemon) startAgent() error {
muxListener, err := createMuxListener()
if err != nil {
return err
}
mux, err := proxy.NewTCPMux(muxListener)
if err != nil {
return err
}
agentIP := options.OutboundIP
if agentIP == "" {
var err error
agentIP, err = utils.GetIPAddress()
if err != nil {
glog.Fatalf("Failed to acquire ip address: %s", err)
}
}
rpcPort := "0"
parts := strings.Split(options.Listen, ":")
if len(parts) > 1 {
rpcPort = parts[1]
}
thisHost, err := host.Build(agentIP, rpcPort, "unknown")
if err != nil {
panic(err)
}
myHostID, err := utils.HostID()
if err != nil {
return fmt.Errorf("HostID failed: %v", err)
} else if err := validation.ValidHostID(myHostID); err != nil {
glog.Errorf("invalid hostid: %s", myHostID)
}
go func() {
var poolID string
for {
poolID = func() string {
glog.Infof("Trying to discover my pool...")
var myHost *host.Host
masterClient, err := master.NewClient(d.servicedEndpoint)
if err != nil {
glog.Errorf("master.NewClient failed (endpoint %+v) : %v", d.servicedEndpoint, err)
return ""
}
defer masterClient.Close()
myHost, err = masterClient.GetHost(myHostID)
if err != nil {
glog.Warningf("masterClient.GetHost %v failed: %v (has this host been added?)", myHostID, err)
return ""
}
poolID = myHost.PoolID
glog.Infof(" My PoolID: %v", poolID)
//send updated host info
updatedHost, err := host.UpdateHostInfo(*myHost)
if err != nil {
glog.Infof("Could not send updated host information: %v", err)
return poolID
}
err = masterClient.UpdateHost(updatedHost)
if err != nil {
glog.Warningf("Could not update host information: %v", err)
return poolID
}
glog.V(2).Infof("Sent updated host info %#v", updatedHost)
return poolID
}()
if poolID != "" {
break
}
select {
case <-d.shutdown:
return
case <-time.After(5 * time.Second):
continue
}
}
thisHost.PoolID = poolID
basePoolPath := "/pools/" + poolID
dsn := coordzk.NewDSN(options.Zookeepers, time.Second*15).String()
glog.Infof("zookeeper dsn: %s", dsn)
zClient, err := coordclient.New("zookeeper", dsn, basePoolPath, nil)
if err != nil {
glog.Errorf("failed create a new coordclient: %v", err)
}
zzk.InitializeLocalClient(zClient)
poolBasedConn, err := zzk.GetLocalConnection(zzk.GeneratePoolPath(poolID))
if err != nil {
glog.Errorf("Error in getting a connection based on pool %v: %v", poolID, err)
}
if options.NFSClient != "0" {
nfsClient, err := storage.NewClient(thisHost, path.Join(options.VarPath, "volumes"))
if err != nil {
glog.Fatalf("could not create an NFS client: %s", err)
}
go func() {
<-d.shutdown
glog.Infof("shutting down storage client")
nfsClient.Close()
}()
//loop and log waiting for Storage Leader
nfsDone := make(chan struct{})
go func() {
defer close(nfsDone)
nfsClient.Wait()
}()
//wait indefinitely(?) for storage to work before starting
glog.Info("Waiting for Storage Leader")
nfsUp := false
for !nfsUp {
select {
case <-nfsDone:
nfsUp = true
glog.Info("Found Storage Leader")
break
case <-time.After(time.Second * 30):
glog.Info("Waiting for Storage Leader, will not be available for running services. ")
continue
}
}
} else {
glog.Info("NFS Client disabled")
}
agentOptions := node.AgentOptions{
PoolID: thisHost.PoolID,
Master: options.Endpoint,
UIPort: options.UIPort,
RPCPort: options.RPCPort,
DockerDNS: options.DockerDNS,
VarPath: options.VarPath,
Mount: options.Mount,
FSType: options.FSType,
Zookeepers: options.Zookeepers,
Mux: mux,
UseTLS: options.TLS,
DockerRegistry: dockerRegistry,
MaxContainerAge: time.Duration(int(time.Second) * options.MaxContainerAge),
VirtualAddressSubnet: options.VirtualAddressSubnet,
}
// creates a zClient that is not pool based!
hostAgent, err := node.NewHostAgent(agentOptions)
d.hostAgent = hostAgent
d.waitGroup.Add(1)
go func() {
hostAgent.Start(d.shutdown)
glog.Info("Host Agent has shutdown")
d.waitGroup.Done()
}()
// register the API
glog.V(0).Infoln("registering ControlPlaneAgent service")
if err = d.rpcServer.RegisterName("ControlPlaneAgent", hostAgent); err != nil {
glog.Fatalf("could not register ControlPlaneAgent RPC server: %v", err)
}
if options.ReportStats {
statsdest := fmt.Sprintf("http://%s/api/metrics/store", options.HostStats)
statsduration := time.Duration(options.StatsPeriod) * time.Second
glog.V(1).Infoln("Staring container statistics reporter")
statsReporter, err := stats.NewStatsReporter(statsdest, statsduration, poolBasedConn)
if err != nil {
glog.Errorf("Error kicking off stats reporter %v", err)
} else {
go func() {
defer statsReporter.Close()
<-d.shutdown
}()
}
}
}()
glog.Infof("agent start staticips: %v [%d]", d.staticIPs, len(d.staticIPs))
if err = d.rpcServer.RegisterName("Agent", agent.NewServer(d.staticIPs)); err != nil {
glog.Fatalf("could not register Agent RPC server: %v", err)
}
if err != nil {
glog.Fatalf("Could not start ControlPlane agent: %v", err)
}
// TODO: Integrate this server into the rpc server, or something.
// Currently its only use is for command execution.
go func() {
sio := shell.NewProcessExecutorServer(options.Endpoint, dockerRegistry)
http.ListenAndServe(":50000", sio)
}()
return nil
}