func (fs *FileSystem) String() string { return fmt.Sprintf("Tree: %d inodes, total file size: %s, number of hashes: %d\nObjectCache: %d objects\n", len(fs.RegularInodeTable)+len(fs.SymlinkInodeTable)+len(fs.InodeTable)+ len(fs.DirectoryInodeList), fsrateio.FormatBytes(fs.TotalDataBytes), fs.HashCount, len(fs.ObjectCache)) }
func (fsh *FileSystemHistory) writeHtml(writer io.Writer) { fmt.Fprintf(writer, "Scan count: %d<br>\n", fsh.scanCount) fmt.Fprintf(writer, "Generation count: %d<br>\n", fsh.generationCount) if fsh.scanCount > 0 { fmt.Fprintf(writer, "Last scan completed: %s<br>\n", fsh.timeOfLastScan) fmt.Fprintf(writer, "Duration of last scan: %s<br>\n", fsh.durationOfLastScan) fsh.fileSystem.WriteHtml(writer) tmp := fsrateio.FormatBytes(uint64(float64( fsh.fileSystem.TotalDataBytes) / fsh.durationOfLastScan.Seconds())) fmt.Fprintf(writer, "Scan rate: %s/s<br>\n", tmp) } fmt.Fprintf(writer, "Duration of current scan: %s<br>\n", time.Since(fsh.timeOfLastScan)) if fsh.generationCount > 0 { fmt.Fprintf(writer, "Last change: %s<br>\n", fsh.timeOfLastChange) } }
// Benchmark the read speed of the underlying block device for a given file. func main() { pathname := "/" if len(os.Args) == 2 { pathname = os.Args[1] } bytesPerSecond, blocksPerSecond, err := fsbench.GetReadSpeed(pathname) if err != nil { fmt.Printf("Error! %s\n", err) return } ctx := fsrateio.NewContext(bytesPerSecond, blocksPerSecond) fmt.Println(ctx) var file *os.File file, err = os.Open(pathname) if err != nil { fmt.Printf("Error! %s\n", err) return } rd := bufio.NewReader(fsrateio.NewReader(file, ctx)) buffer := make([]byte, 65536) timeStart := time.Now() tread := 0 for { n := 0 n, err = rd.Read(buffer) if n < 1 && err == io.EOF { break } if err != nil { fmt.Printf("Error! %s\n", err) return } tread += n } bytesPerSecond = uint64(float64(tread) / time.Since(timeStart).Seconds()) fmt.Printf("%s/s\n", fsrateio.FormatBytes(bytesPerSecond)) }
func (fs *FileSystem) writeHtml(writer io.Writer) { fmt.Fprintf(writer, "Scanned: %s<br>\n", fsrateio.FormatBytes(fs.TotalDataBytes)) }
func main() { flag.Parse() var err error bytesPerSecond, blocksPerSecond, err := fsbench.GetReadSpeed(*rootDir) if err != nil { fmt.Printf("Error! %s\n", err) return } ctx := fsrateio.NewContext(bytesPerSecond, blocksPerSecond) if *scanSpeed != 0 { ctx.SetSpeedPercent(*scanSpeed) } fmt.Println(ctx) syscall.Setpriority(syscall.PRIO_PROCESS, 0, 10) var prev_fs *scanner.FileSystem sleepDuration, _ := time.ParseDuration(fmt.Sprintf("%ds", *interval)) for iter := 0; *numScans < 0 || iter < *numScans; iter++ { timeStart := time.Now() fs, err := scanner.ScanFileSystem(*rootDir, *objectCache, ctx) timeStop := time.Now() if iter > 0 { fmt.Println() } if err != nil { fmt.Printf("Error! %s\n", err) return } fmt.Print(fs) fmt.Printf("Total scanned: %s,\t", fsrateio.FormatBytes(fs.TotalDataBytes)) bytesPerSecond := uint64(float64(fs.TotalDataBytes) / timeStop.Sub(timeStart).Seconds()) fmt.Printf("%s/s\n", fsrateio.FormatBytes(bytesPerSecond)) if prev_fs != nil { if !scanner.Compare(prev_fs, fs, os.Stdout) { fmt.Println("Scan results different from last run") } } runtime.GC() // Clean up before showing memory statistics. memstats.WriteMemoryStats(os.Stdout) if *debugFile != "" { file, err := os.Create(*debugFile) if err != nil { fmt.Printf("Error! %s\n", err) return } w := bufio.NewWriter(file) fs.DebugWrite(w, "") w.Flush() file.Close() } if *rpcFile != "" { file, err := os.Create(*rpcFile) if err != nil { fmt.Printf("Error creating: %s\t%s\n", *rpcFile, err) os.Exit(1) } encoder := gob.NewEncoder(file) encoder.Encode(fs) file.Close() } prev_fs = fs time.Sleep(sleepDuration) } }
func writeNamedStat(writer io.Writer, name string, value uint64) { fmt.Fprintf(writer, " %s=%s\n", name, fsrateio.FormatBytes(value)) }