func newHerd(imageServerAddress string, objectServer objectserver.ObjectServer,
logger *log.Logger) *Herd {
var herd Herd
herd.imageManager = images.New(imageServerAddress, logger)
herd.objectServer = objectServer
herd.computedFilesManager = filegenclient.New(objectServer, logger)
herd.logger = logger
herd.configurationForSubs.ScanSpeedPercent =
constants.DefaultScanSpeedPercent
herd.configurationForSubs.NetworkSpeedPercent =
constants.DefaultNetworkSpeedPercent
herd.configurationForSubs.ScanExclusionList =
constants.ScanExcludeList
herd.subsByName = make(map[string]*Sub)
numPollSlots := uint(runtime.NumCPU()) * *pollSlotsPerCPU
herd.pollSemaphore = make(chan struct{}, numPollSlots)
herd.pushSemaphore = make(chan struct{}, runtime.NumCPU())
numComputeSlots := runtime.NumCPU() - 1
if numComputeSlots < 1 {
numComputeSlots = 1
}
herd.computeSemaphore = make(chan struct{}, numComputeSlots)
herd.currentScanStartTime = time.Now()
return &herd
}
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)
}
}
}
}