1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120
|
package sigar
import (
"os"
"os/exec"
"runtime"
"time"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/gexec"
)
var _ = Describe("SigarShared", func() {
Describe("ProcCpu", func() {
var (
cpuGenerator *exec.Cmd
noCPUGenerator *exec.Cmd
)
BeforeEach(func() {
pathToStress, err := gexec.Build("github.com/cloudfoundry/gosigar/fixtures/stress")
Expect(err).NotTo(HaveOccurred())
cpuGenerator = exec.Command(pathToStress)
if err := cpuGenerator.Start(); err != nil {
panic("failed to start cpu generator")
}
noCPUCommand := "cat"
if runtime.GOOS == "windows" {
noCPUCommand = "notepad.exe"
}
noCPUGenerator = exec.Command(noCPUCommand)
if err := noCPUGenerator.Start(); err != nil {
panic("failed to start no cpu generator")
}
})
AfterEach(func() {
cpuGenerator.Process.Signal(os.Kill)
noCPUGenerator.Process.Signal(os.Kill)
})
It("calculates percentage", func() {
time.Sleep(time.Second) // High CPU process needs a second to spool up
pCpu := &ProcCpu{}
err := pCpu.Get(cpuGenerator.Process.Pid)
Expect(err).ToNot(HaveOccurred())
Expect(pCpu.Percent).To(BeNumerically("~", 1.0, 0.1))
})
It("does not conflate multiple processes", func() {
time.Sleep(time.Second) // High CPU process needs a second to spool up
pCpu := &ProcCpu{}
err := pCpu.Get(cpuGenerator.Process.Pid)
Expect(err).ToNot(HaveOccurred())
err = pCpu.Get(noCPUGenerator.Process.Pid)
Expect(err).ToNot(HaveOccurred())
Expect(pCpu.Percent).To(BeNumerically("~", 0.0, 0.02))
})
})
Describe("ProcMem", func() {
var memGenerator *exec.Cmd
var noMemGenerator *exec.Cmd
BeforeEach(func() {
pathToMemory, err := gexec.Build("github.com/cloudfoundry/gosigar/fixtures/memory")
Expect(err).NotTo(HaveOccurred())
memGenerator = exec.Command(pathToMemory, "-count", "16000000")
if err := memGenerator.Start(); err != nil {
panic("failed to start mem generator")
}
noMemGenerator = exec.Command(pathToMemory, "-count", "0")
if err := noMemGenerator.Start(); err != nil {
panic("failed to start no mem generator")
}
})
AfterEach(func() {
memGenerator.Process.Signal(os.Kill)
noMemGenerator.Process.Signal(os.Kill)
})
It("calculates memory usage", func() {
pMem := &ProcMem{}
Eventually(func() uint64 {
err := pMem.Get(memGenerator.Process.Pid)
Expect(err).NotTo(HaveOccurred())
return pMem.Resident
}, 5*time.Second).Should(BeNumerically("~", 18000000, 5*1024*1024))
Eventually(func() uint64 {
err := pMem.Get(memGenerator.Process.Pid)
Expect(err).NotTo(HaveOccurred())
return pMem.Size
}, 5*time.Second).Should(BeNumerically(">=", pMem.Resident))
pNoMem := &ProcMem{}
Eventually(func() uint64 {
err := pNoMem.Get(noMemGenerator.Process.Pid)
Expect(err).NotTo(HaveOccurred())
return pNoMem.Resident
}, 5*time.Second).Should(BeNumerically("~", 2000000, 5*1024*1024))
Eventually(func() uint64 {
err := pNoMem.Get(noMemGenerator.Process.Pid)
Expect(err).NotTo(HaveOccurred())
return pNoMem.Size
}, 5*time.Second).Should(BeNumerically(">=", pNoMem.Resident))
})
})
})
|