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