func mkdir(name string) *tricorder.DirectorySpec {
dir, err := tricorder.RegisterDirectory(name)
if err != nil {
panic(err)
}
return dir
}
func (pool *Pool) registerMetrics(metricsSubDirname string) {
if metricsSubDirname == "" {
return
}
dir, err := tricorder.RegisterDirectory("resourcepool/" + metricsSubDirname)
if err != nil {
panic(err)
}
err = dir.RegisterMetric("maximum", &pool.max, units.None,
"maximum capacity")
if err != nil {
panic(err)
}
err = dir.RegisterMetric("num-in-use", &pool.numUsed, units.None,
"number in use")
if err != nil {
panic(err)
}
err = dir.RegisterMetric("num-unused", &pool.numUnused, units.None,
"number in use")
if err != nil {
panic(err)
}
err = dir.RegisterMetric("num-releasing", &pool.numReleasing, units.None,
"number being released")
if err != nil {
panic(err)
}
}
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 setupProbers() ([]prober, error) {
topMetricsDir, err := tricorder.RegisterDirectory("/sys")
if err != nil {
return nil, err
}
var probers []prober
probers = append(probers, filesystems.Register(mkdir(topMetricsDir, "fs")))
probers = append(probers, loadavg.Register(mkdir(topMetricsDir, "loadavg")))
probers = append(probers, memory.Register(mkdir(topMetricsDir, "memory")))
probers = append(probers, netif.Register(mkdir(topMetricsDir, "netif")))
probers = append(probers, network.Register(mkdir(topMetricsDir, "network")))
probers = append(probers, storage.Register(mkdir(topMetricsDir, "storage")))
probers = append(probers, systime.Register(mkdir(topMetricsDir, "")))
return probers, nil
}
func newStore(
t *testing.T,
testName string,
valueCount,
pageCount uint,
inactiveThreshhold float64,
degree uint) *store.Store {
result := store.NewStore(
valueCount, pageCount, inactiveThreshhold, degree)
dirSpec, err := tricorder.RegisterDirectory("/" + testName)
if err != nil {
t.Fatalf("Duplicate test: %s", testName)
}
result.RegisterMetrics(dirSpec)
return result
}
func registerServerMetrics() {
var err error
serverMetricsDir, err = tricorder.RegisterDirectory("srpc/server")
if err != nil {
panic(err)
}
err = serverMetricsDir.RegisterMetric("num-connections",
&numServerConnections, units.None, "number of connection attempts")
if err != nil {
panic(err)
}
err = serverMetricsDir.RegisterMetric("num-open-connections",
&numOpenServerConnections, units.None, "number of open connections")
if err != nil {
panic(err)
}
err = serverMetricsDir.RegisterMetric("num-rejected-connections",
&numRejectedServerConnections, units.None,
"number of rejected connections")
if err != nil {
panic(err)
}
bucketer = tricorder.NewGeometricBucketer(0.1, 1e5)
}
func registerMetrics() {
var temperature float64
var someBool bool
var someDuration time.Duration
rpcDistribution := tricorder.PowersOfTen.NewCumulativeDistribution()
var sample []int
kAnIntList = tricorder.NewList(sample, tricorder.MutableSlice)
if err := tricorder.RegisterMetric(
"/list/squares",
kAnIntList,
units.None,
"Squares"); err != nil {
log.Fatalf("Got error %v registering metric", err)
}
if err := tricorder.RegisterMetric(
"/proc/rpc-latency",
rpcDistribution,
units.Millisecond,
"RPC latency"); err != nil {
log.Fatalf("Got error %v registering metric", err)
}
if err := tricorder.RegisterMetric(
"/proc/rpc-count",
rpcCountCallback,
units.Unknown,
"RPC count"); err != nil {
log.Fatalf("Got error %v registering metric", err)
}
if err := tricorder.RegisterMetric("/proc/temperature", &temperature, units.Celsius, "Temperature"); err != nil {
log.Fatalf("Got error %v registering metric", err)
}
if err := tricorder.RegisterMetric("/proc/duration", &someDuration, units.Second, "Duration"); err != nil {
log.Fatalf("Got error %v registering metric", err)
}
fooDir, err := tricorder.RegisterDirectory("proc/foo")
if err != nil {
log.Fatalf("Got error %v registering directory", err)
}
barDir, err := fooDir.RegisterDirectory("bar")
if err != nil {
log.Fatalf("Got error %v registering directory", err)
}
err = barDir.RegisterMetric(
"baz",
bazCallback,
units.None,
"Another float value")
if err != nil {
log.Fatalf("Got error %v registering metric", err)
}
err = barDir.RegisterMetric("abool", &someBool, units.None, "A boolean value")
if err != nil {
log.Fatalf("Got error %v registering metric", err)
}
temperature = 22.5
someBool = true
someDuration = 2*time.Minute + 5*time.Second
// Add data points to the distribution
// < 10: 10
// 10 - 25: 15
// 25 - 62.5: 38
// 62.5 - 156.25: 94
// 156.25 - 390.625: 234
for i := 0; i < 500; i++ {
rpcDistribution.Add(float64(i))
}
go updateList()
}
func main() {
flag.Parse()
tricorder.RegisterFlags()
setupTls(*caFile, *certFile, *keyFile)
subdDirPathname := path.Join(*rootDir, *subdDir)
workingRootDir := path.Join(subdDirPathname, "root")
objectsDir := path.Join(workingRootDir, *subdDir, "objects")
tmpDir := path.Join(subdDirPathname, "tmp")
netbenchFilename := path.Join(subdDirPathname, "netbench")
oldTriggersFilename := path.Join(subdDirPathname, "triggers.previous")
if !createDirectory(workingRootDir) {
os.Exit(1)
}
if !sanityCheck() {
os.Exit(1)
}
if !createDirectory(tmpDir) {
os.Exit(1)
}
if !mountTmpfs(tmpDir) {
os.Exit(1)
}
if !unshareAndBind(workingRootDir) {
os.Exit(1)
}
if !createDirectory(objectsDir) {
os.Exit(1)
}
runtime.GOMAXPROCS(int(*maxThreads))
bytesPerSecond, blocksPerSecond, firstScan, ok := getCachedFsSpeed(
workingRootDir, tmpDir)
if !ok {
os.Exit(1)
}
circularBuffer := logbuf.New(*logbufLines)
logger := log.New(circularBuffer, "", log.LstdFlags)
var configuration scanner.Configuration
var err error
configuration.ScanFilter, err = filter.NewFilter(constants.ScanExcludeList)
if err != nil {
fmt.Fprintf(os.Stderr, "Unable to set default scan exclusions\t%s\n",
err)
os.Exit(1)
}
configuration.FsScanContext = fsrateio.NewReaderContext(bytesPerSecond,
blocksPerSecond, 0)
defaultSpeed := configuration.FsScanContext.GetContext().SpeedPercent()
if firstScan {
configuration.FsScanContext.GetContext().SetSpeedPercent(100)
}
if *showStats {
fmt.Println(configuration.FsScanContext)
}
var fsh scanner.FileSystemHistory
fsChannel, disableScanner := scanner.StartScannerDaemon(workingRootDir,
objectsDir, &configuration, logger)
networkReaderContext := rateio.NewReaderContext(
getCachedNetworkSpeed(netbenchFilename),
constants.DefaultNetworkSpeedPercent, &rateio.ReadMeasurer{})
configuration.NetworkReaderContext = networkReaderContext
rescanObjectCacheChannel := rpcd.Setup(&configuration, &fsh, objectsDir,
networkReaderContext, netbenchFilename, oldTriggersFilename,
disableScanner, logger)
configMetricsDir, err := tricorder.RegisterDirectory("/config")
if err != nil {
fmt.Fprintf(os.Stderr,
"Unable to create /config metrics directory\t%s\n",
err)
os.Exit(1)
}
configuration.RegisterMetrics(configMetricsDir)
if err != nil {
fmt.Fprintf(os.Stderr, "Unable to create config metrics\t%s\n", err)
os.Exit(1)
}
httpd.AddHtmlWriter(&fsh)
httpd.AddHtmlWriter(&configuration)
httpd.AddHtmlWriter(circularBuffer)
html.RegisterHtmlWriterForPattern("/dumpFileSystem", "Scanned File System",
&DumpableFileSystemHistory{&fsh})
if err = httpd.StartServer(*portNum); err != nil {
fmt.Fprintf(os.Stderr, "Unable to create http server\t%s\n", err)
os.Exit(1)
}
fsh.Update(nil)
invalidateNextScanObjectCache := false
sighupChannel := make(chan os.Signal)
signal.Notify(sighupChannel, syscall.SIGHUP)
sigtermChannel := make(chan os.Signal)
signal.Notify(sigtermChannel, syscall.SIGTERM, syscall.SIGINT)
writePidfile()
for iter := 0; true; {
select {
case <-sighupChannel:
err = syscall.Exec(os.Args[0], os.Args, os.Environ())
if err != nil {
logger.Printf("Unable to Exec:%s\t%s\n", os.Args[0], err)
}
case <-sigtermChannel:
gracefulCleanup()
case fs := <-fsChannel:
if *showStats {
fmt.Printf("Completed cycle: %d\n", iter)
}
if invalidateNextScanObjectCache {
fs.ScanObjectCache()
invalidateNextScanObjectCache = false
}
fsh.Update(fs)
iter++
runtime.GC() // An opportune time to take out the garbage.
if *showStats {
fmt.Print(fsh)
fmt.Print(fsh.FileSystem())
memstats.WriteMemoryStats(os.Stdout)
fmt.Println()
}
if firstScan {
configuration.FsScanContext.GetContext().SetSpeedPercent(
defaultSpeed)
firstScan = false
if *showStats {
fmt.Println(configuration.FsScanContext)
}
}
case <-rescanObjectCacheChannel:
invalidateNextScanObjectCache = true
fsh.UpdateObjectCacheOnly()
}
}
}