18 func CopyPipeToChan(in io.Reader, out chan string, done chan<- bool) {
19 s := bufio.NewScanner(in)
26 func CopyChanToPipe(in <-chan string, out io.Writer) {
32 func FindStat(cgroup_root string, cgroup_parent string, container_id string, statgroup string, stat string) string {
34 path = fmt.Sprintf("%s/%s/%s/%s/%s.%s", cgroup_root, statgroup, cgroup_parent, container_id, statgroup, stat)
35 if _, err := os.Stat(path); err == nil {
38 path = fmt.Sprintf("%s/%s/%s/%s.%s", cgroup_root, cgroup_parent, container_id, statgroup, stat)
39 if _, err := os.Stat(path); err == nil {
42 path = fmt.Sprintf("%s/%s/%s.%s", cgroup_root, statgroup, statgroup, stat)
43 if _, err := os.Stat(path); err == nil {
46 path = fmt.Sprintf("%s/%s.%s", cgroup_root, statgroup, stat)
47 if _, err := os.Stat(path); err == nil {
53 func PollCgroupStats(cgroup_root string, cgroup_parent string, container_id string, stderr chan string, poll int64, stop_poll_chan <-chan bool) {
54 //var last_usage int64 = 0
55 var last_user int64 = -1
56 var last_sys int64 = -1
57 var last_cpucount int64 = 0
66 disk := make(map[string]*Disk)
68 //cpuacct_usage := FindStat(cgroup_path, "cpuacct", "usage")
69 cpuacct_stat := FindStat(cgroup_root, cgroup_parent, container_id, "cpuacct", "stat")
70 blkio_io_service_bytes := FindStat(cgroup_root, cgroup_parent, container_id, "blkio", "io_service_bytes")
71 cpuset_cpus := FindStat(cgroup_root, cgroup_parent, container_id, "cpuset", "cpus")
72 memory_stat := FindStat(cgroup_root, cgroup_parent, container_id, "memory", "stat")
74 if cpuacct_stat != "" {
75 stderr <- fmt.Sprintf("crunchstat: reading stats from %s", cpuacct_stat)
77 if blkio_io_service_bytes != "" {
78 stderr <- fmt.Sprintf("crunchstat: reading stats from %s", blkio_io_service_bytes)
80 if cpuset_cpus != "" {
81 stderr <- fmt.Sprintf("crunchstat: reading stats from %s", cpuset_cpus)
83 if memory_stat != "" {
84 stderr <- fmt.Sprintf("crunchstat: reading stats from %s", memory_stat)
87 poll_chan := make(chan bool, 1)
89 // Send periodic poll events.
92 time.Sleep(time.Duration(poll) * time.Millisecond)
99 case <-stop_poll_chan:
102 // Emit stats, then select again.
104 morning := time.Now()
105 elapsed := morning.Sub(bedtime).Nanoseconds() / int64(time.Millisecond)
107 c, _ := os.Open(cpuacct_usage)
108 b, _ := ioutil.ReadAll(c)
110 fmt.Sscanf(string(b), "%d", &next)
112 stderr <- fmt.Sprintf("crunchstat: cpuacct.usage %v", (next-last_usage)/10000000)
114 //fmt.Printf("usage %d %d %d %d%%\n", last_usage, next, next-last_usage, (next-last_usage)/10000000)
119 if cpuset_cpus != "" {
120 c, err := os.Open(cpuset_cpus)
122 stderr <- fmt.Sprintf("open %s: %s", cpuset_cpus, err)
123 // cgroup probably gone -- skip other stats too.
126 b, _ := ioutil.ReadAll(c)
127 sp := strings.Split(string(b), ",")
128 for _, v := range sp {
130 n, _ := fmt.Sscanf(v, "%d-%d", &min, &max)
132 cpus += (max - min) + 1
138 if cpus != last_cpucount {
139 stderr <- fmt.Sprintf("crunchstat: cpuset.cpus %v", cpus)
148 if cpuacct_stat != "" {
149 c, err := os.Open(cpuacct_stat)
151 stderr <- fmt.Sprintf("open %s: %s", cpuacct_stat, err)
152 // Next time around, last_user would
153 // be >1 interval old, so stats will
154 // be incorrect. Start over instead.
157 // cgroup probably gone -- skip other stats too.
160 b, _ := ioutil.ReadAll(c)
163 fmt.Sscanf(string(b), "user %d\nsystem %d", &next_user, &next_sys)
166 if elapsed > 0 && last_user != -1 {
167 user_diff := next_user - last_user
168 sys_diff := next_sys - last_sys
169 // Assume we're reading stats based on 100
170 // jiffies per second. Because the elapsed
171 // time is in milliseconds, we need to boost
172 // that to 1000 jiffies per second, then boost
173 // it by another 100x to get a percentage, then
174 // finally divide by the actual elapsed time
175 // and the number of cpus to get average load
176 // over the polling period.
177 user_pct := (user_diff * 10 * 100) / (elapsed * cpus)
178 sys_pct := (sys_diff * 10 * 100) / (elapsed * cpus)
180 stderr <- fmt.Sprintf("crunchstat: cpuacct.stat user %v", user_pct)
181 stderr <- fmt.Sprintf("crunchstat: cpuacct.stat sys %v", sys_pct)
184 /*fmt.Printf("user %d %d %d%%\n", last_user, next_user, next_user-last_user)
185 fmt.Printf("sys %d %d %d%%\n", last_sys, next_sys, next_sys-last_sys)
186 fmt.Printf("sum %d%%\n", (next_user-last_user)+(next_sys-last_sys))*/
187 last_user = next_user
190 if blkio_io_service_bytes != "" {
191 c, err := os.Open(blkio_io_service_bytes)
193 stderr <- fmt.Sprintf("open %s: %s", blkio_io_service_bytes, err)
194 // cgroup probably gone -- skip other stats too.
197 b := bufio.NewScanner(c)
198 var device, op string
201 if _, err := fmt.Sscanf(string(b.Text()), "%s %s %d", &device, &op, &next); err == nil {
202 if disk[device] == nil {
203 disk[device] = new(Disk)
206 disk[device].last_read = disk[device].next_read
207 disk[device].next_read = next
208 if disk[device].last_read > 0 && (disk[device].next_read != disk[device].last_read) {
209 stderr <- fmt.Sprintf("crunchstat: blkio.io_service_bytes %s read %v", device, disk[device].next_read-disk[device].last_read)
213 disk[device].last_write = disk[device].next_write
214 disk[device].next_write = next
215 if disk[device].last_write > 0 && (disk[device].next_write != disk[device].last_write) {
216 stderr <- fmt.Sprintf("crunchstat: blkio.io_service_bytes %s write %v", device, disk[device].next_write-disk[device].last_write)
224 if memory_stat != "" {
225 c, err := os.Open(memory_stat)
227 stderr <- fmt.Sprintf("open %s: %s", memory_stat, err)
228 // cgroup probably gone -- skip other stats too.
231 b := bufio.NewScanner(c)
235 if _, err := fmt.Sscanf(string(b.Text()), "%s %d", &stat, &val); err == nil {
237 stderr <- fmt.Sprintf("crunchstat: memory.stat rss %v", val)
246 func run(logger *log.Logger) error {
251 cgroup_cidfile string
256 flag.StringVar(&cgroup_root, "cgroup-root", "", "Root of cgroup tree")
257 flag.StringVar(&cgroup_parent, "cgroup-parent", "", "Name of container parent under cgroup")
258 flag.StringVar(&cgroup_cidfile, "cgroup-cid", "", "Path to container id file")
259 flag.Int64Var(&wait, "wait", 5, "Maximum time (in seconds) to wait for cid file to show up")
260 flag.Int64Var(&poll, "poll", 1000, "Polling frequency, in milliseconds")
264 if cgroup_root == "" {
265 logger.Fatal("Must provide -cgroup-root")
268 stderr_chan := make(chan string, 1)
269 defer close(stderr_chan)
270 finish_chan := make(chan bool)
271 defer close(finish_chan)
273 go CopyChanToPipe(stderr_chan, os.Stderr)
277 if len(flag.Args()) > 0 {
279 cmd = exec.Command(flag.Args()[0], flag.Args()[1:]...)
281 logger.Print("Running ", flag.Args())
283 // Child process will use our stdin and stdout pipes
284 // (we close our copies below)
286 cmd.Stdout = os.Stdout
288 // Forward SIGINT and SIGTERM to inner process
289 term := make(chan os.Signal, 1)
290 go func(sig <-chan os.Signal) {
292 if cmd.Process != nil {
293 cmd.Process.Signal(catch)
295 logger.Print("caught signal: ", catch)
297 signal.Notify(term, syscall.SIGTERM)
298 signal.Notify(term, syscall.SIGINT)
300 // Funnel stderr through our channel
301 stderr_pipe, err := cmd.StderrPipe()
305 go CopyPipeToChan(stderr_pipe, stderr_chan, finish_chan)
308 if err := cmd.Start(); err != nil {
312 // Close stdin/stdout in this (parent) process
318 var container_id string
319 if cgroup_cidfile != "" {
320 // wait up to 'wait' seconds for the cid file to appear
323 for i = 0; i < time.Duration(wait)*time.Second; i += (100 * time.Millisecond) {
324 f, err := os.Open(cgroup_cidfile)
327 cid, err2 := ioutil.ReadAll(f)
328 if err2 == nil && len(cid) > 0 {
330 container_id = string(cid)
334 time.Sleep(100 * time.Millisecond)
337 logger.Printf("Could not read cid file %s", cgroup_cidfile)
341 stop_poll_chan := make(chan bool, 1)
342 go PollCgroupStats(cgroup_root, cgroup_parent, container_id, stderr_chan, poll, stop_poll_chan)
344 // When the child exits, tell the polling goroutine to stop.
345 defer func() { stop_poll_chan <- true }()
347 // Wait for CopyPipeToChan to consume child's stderr pipe
354 logger := log.New(os.Stderr, "crunchstat: ", 0)
355 if err := run(logger); err != nil {
356 if exiterr, ok := err.(*exec.ExitError); ok {
357 // The program has exited with an exit code != 0
359 // This works on both Unix and
360 // Windows. Although package syscall is
361 // generally platform dependent, WaitStatus is
362 // defined for both Unix and Windows and in
363 // both cases has an ExitStatus() method with
364 // the same signature.
365 if status, ok := exiterr.Sys().(syscall.WaitStatus); ok {
366 os.Exit(status.ExitStatus())
369 logger.Fatalf("cmd.Wait: %v", err)