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 createApplicationStats(
appList *datastructs.ApplicationList,
logger *log.Logger,
tagvAdder suggest.Adder,
maybeNilMemoryManager *memoryManagerType) *datastructs.ApplicationStatuses {
var astore *store.Store
fmt.Println("Initialization started.")
if maybeNilMemoryManager != nil {
memoryManager := maybeNilMemoryManager
astore = store.NewStoreBytesPerPage(
*fBytesPerPage,
1,
*fThreshhold,
*fDegree)
astore.SetExpanding(true)
memoryManager.SetMemory(astore)
if err := memoryManager.RegisterMetrics(); err != nil {
log.Fatal(err)
}
} else {
astore = store.NewStoreBytesPerPage(
*fBytesPerPage, *fPageCount, *fThreshhold, *fDegree)
}
dirSpec, err := tricorder.RegisterDirectory("/store")
if err != nil {
log.Fatal(err)
}
if err := astore.RegisterMetrics(dirSpec); err != nil {
log.Fatal(err)
}
stats := datastructs.NewApplicationStatuses(appList, astore)
mdbChannel := mdbd.StartMdbDaemon(*fMdbFile, logger)
machines := <-mdbChannel
theHostNames := hostNames(machines.Machines)
for _, aName := range theHostNames {
tagvAdder.Add(aName)
}
stats.MarkHostsActiveExclusively(
duration.TimeToFloat(time.Now()), theHostNames)
fmt.Println("Initialization complete.")
// Endpoint refresher goroutine
go func() {
for {
machines := <-mdbChannel
stats.MarkHostsActiveExclusively(
duration.TimeToFloat(time.Now()),
hostNames(machines.Machines))
}
}()
return stats
}
func main() {
flag.Parse()
tricorder.RegisterFlags()
circularBuffer := logbuf.New()
logger := log.New(circularBuffer, "", log.LstdFlags)
if err := setupserver.SetupTls(); err != nil {
logger.Println(err)
circularBuffer.Flush()
if !*permitInsecureMode {
os.Exit(1)
}
}
rlim := syscall.Rlimit{*fdLimit, *fdLimit}
if err := syscall.Setrlimit(syscall.RLIMIT_NOFILE, &rlim); err != nil {
fmt.Fprintf(os.Stderr, "Cannot set FD limit\t%s\n", err)
os.Exit(1)
}
if os.Geteuid() == 0 {
if err := setUser(*username); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
}
fi, err := os.Lstat(*stateDir)
if err != nil {
fmt.Fprintf(os.Stderr, "Cannot stat: %s\t%s\n", *stateDir, err)
os.Exit(1)
}
if !fi.IsDir() {
fmt.Fprintf(os.Stderr, "%s is not a directory\n", *stateDir)
os.Exit(1)
}
interval := time.Duration(*minInterval) * time.Second
mdbChannel := mdbd.StartMdbDaemon(path.Join(*stateDir, *mdbFile), logger)
objectServer, err := newObjectServer(path.Join(*stateDir, *objectsDir),
logger)
if err != nil {
fmt.Fprintf(os.Stderr, "Cannot load objectcache: %s\n", err)
os.Exit(1)
}
herd := herd.NewHerd(fmt.Sprintf("%s:%d", *imageServerHostname,
*imageServerPortNum), objectServer, logger)
herd.AddHtmlWriter(circularBuffer)
rpcd.Setup(herd, logger)
if err = herd.StartServer(*portNum, true); err != nil {
fmt.Fprintf(os.Stderr, "Unable to create http server\t%s\n", err)
os.Exit(1)
}
scanTokenChannel := make(chan bool, 1)
scanTokenChannel <- true
nextCycleStopTime := time.Now().Add(interval)
for {
select {
case mdb := <-mdbChannel:
herd.MdbUpdate(mdb)
if *debug {
showMdb(mdb)
}
case <-scanTokenChannel:
// Scan one sub.
if herd.PollNextSub() { // We've reached the end of a scan cycle.
if *debug {
fmt.Print(".")
}
go func(sleepDuration time.Duration) {
time.Sleep(sleepDuration)
nextCycleStopTime = time.Now().Add(interval)
scanTokenChannel <- true
}(nextCycleStopTime.Sub(time.Now()))
} else {
scanTokenChannel <- true
}
}
}
}
