func main() {
flag.Usage = printUsage
flag.Parse()
if flag.NArg() != 2 {
printUsage()
os.Exit(2)
}
if err := setupclient.SetupTls(true); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
objectServer := memory.NewObjectServer()
logger := log.New(os.Stdout, "", log.LstdFlags)
manager := client.New(objectServer, logger)
mdbChannel := mdbd.StartMdbDaemon(*mdbFile, logger)
machines := make(map[string]struct{})
computedFiles := make([]client.ComputedFile, 1)
computedFiles[0].Pathname = flag.Arg(0)
computedFiles[0].Source = flag.Arg(1)
messageChannel := make(chan messageType, 1)
if *benchmark {
go benchmarkMessageHandler(messageChannel)
} else {
go displayMessageHandler(messageChannel, objectServer)
}
for {
select {
case mdb := <-mdbChannel:
if *debug {
showMdb(mdb)
}
numMachines = len(mdb.Machines)
machinesToDelete := make(map[string]struct{}, len(machines))
for hostname := range machines {
machinesToDelete[hostname] = struct{}{}
}
for _, mdbEntry := range mdb.Machines {
delete(machinesToDelete, mdbEntry.Hostname)
machine := client.Machine{mdbEntry, computedFiles}
if _, ok := machines[mdbEntry.Hostname]; !ok {
machines[mdbEntry.Hostname] = struct{}{}
go handleUpdates(mdbEntry.Hostname, manager.Add(machine, 1),
messageChannel)
} else {
manager.Update(client.Machine{mdbEntry, computedFiles})
}
}
for hostname := range machinesToDelete {
manager.Remove(hostname)
delete(machines, hostname)
}
}
}
}
func newManager(logger *log.Logger) *Manager {
m := new(Manager)
m.pathManagers = make(map[string]*pathManager)
m.machineData = make(map[string]mdb.Machine)
m.clients = make(
map[<-chan *proto.ServerMessage]chan<- *proto.ServerMessage)
m.objectServer = memory.NewObjectServer()
m.logger = logger
m.registerMdbGeneratorForPath("/etc/mdb.json")
srpc.RegisterName("FileGenerator", &rpcType{m})
return m
}
