summaryrefslogtreecommitdiffhomepage
path: root/Plugins/Monitors/Top.hs
blob: 9885d55743c2e148b23810f8cd65954ee1ddbdfb (plain)
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
-----------------------------------------------------------------------------
-- |
-- Module      :  Plugins.Monitors.Top
-- Copyright   :  (c) Jose A Ortega Ruiz
-- License     :  BSD-style (see LICENSE)
--
-- Maintainer  :  Jose A Ortega Ruiz <jao@gnu.org>
-- Stability   :  unstable
-- Portability :  unportable
--
--  Process activity and memory consumption monitors
--
-----------------------------------------------------------------------------

{-# LANGUAGE ForeignFunctionInterface, BangPatterns #-}

module Plugins.Monitors.Top (startTopCpu, topMemConfig, runTopMem) where

import Plugins.Monitors.Common

import Control.Exception (SomeException, handle, evaluate)
import System.Directory
import System.FilePath
import System.IO
import System.Posix.Unistd (getSysVar, SysVar(ClockTick))
import Foreign.C.Types
import Data.List (sortBy)
import Data.Ord (comparing)
import Data.IORef
import Data.Time.Clock

import Data.IntMap (IntMap)
import qualified Data.IntMap as M


topMemConfig :: IO MConfig
topMemConfig = mkMConfig "<both1>" [ k ++ n | n <- map show [1..maxProc]
                                            , k <- ["name", "rss", "both"]]

topCpuConfig :: IO MConfig
topCpuConfig = mkMConfig "<both1>" [ k ++ n | n <- map show [1..maxProc]
                                            , k <- ["name", "cpu", "both"]]



foreign import ccall "unistd.h getpagesize"
  c_getpagesize :: CInt

pageSize :: Int
pageSize = fromIntegral c_getpagesize `div` 1024

showInfo :: String -> String -> Float -> Monitor [String]
showInfo nm sms mms = do
  mnw <- getConfigValue maxWidth
  mxw <- getConfigValue minWidth
  let lsms = length sms
      nmw = mnw - lsms - 1
      nmx = mxw - lsms - 1
      rnm = if nmw > 0 then padString nmw nmx " " True nm else nm
  mstr <- showWithColors' sms mms
  both <- showWithColors' (rnm ++ " " ++ sms) mms
  return [nm, mstr, both]

strictReadFile :: FilePath -> IO String
strictReadFile f =
  do hdl <- openFile f ReadMode
     xs <- getc hdl
     hClose hdl
     return xs
    where getc hdl = do e <- hIsEOF hdl
                        if e then return []
                          else do c <- hGetChar hdl
                                  cs <- getc hdl
                                  return (c:cs)

getProcessData :: FilePath -> IO [String]
getProcessData pidf =
  handle ((\_ -> evaluate []) :: SomeException -> IO [String])
         (do s <- strictReadFile $ "/proc" </> pidf </> "stat"
             evaluate $! words s)

processes :: IO [FilePath]
processes = fmap (filter isPid) (getDirectoryContents "/proc")
  where isPid = all (`elem` ['0'..'9'])

handleProcesses :: a -> ([String] -> a) -> IO [a]
handleProcesses def f = do
  ps <- processes
  pd <- mapM getProcessData $! ps
  return $! map (\x -> if x == [] then def else f x) pd

processName :: [String] -> String
processName = drop 1 . init . (!!1)

maxProc :: Int
maxProc = 5

type Meminfo = (String, Int)

meminfo :: [String] -> Meminfo
meminfo fs = (n, r)
  where !n = processName fs
        !r = pageSize * read (fs!!23)

meminfos :: IO [Meminfo]
meminfos = handleProcesses ("", 0) meminfo

topMemProcesses :: Int -> IO [Meminfo]
topMemProcesses n = fmap (take n . sbm) meminfos
  where sbm = sortBy (flip (comparing snd))

showMeminfo :: Meminfo -> Monitor [String]
showMeminfo (nm, rss) =
  showInfo nm sms (ms / 1024)
    where ms = fromIntegral rss
          sms = showWithUnits 2 1 ms

runTopMem :: [String] -> Monitor String
runTopMem _ = do
  ps <- io $ topMemProcesses maxProc
  pstr <- mapM showMeminfo ps
  parseTemplate $ concat pstr

type Pid = Int
type TimeInfo = (String, Float)
type TimeEntry = (Pid, TimeInfo)
type Times = IntMap TimeInfo
type TimesRef = IORef (Times, UTCTime)

timeEntry :: [String] -> TimeEntry
timeEntry fs = (p, (n, t))
  where !p = read (head fs)
        !n = processName fs
        !t = read (fs!!13) + read (fs!!14)

timeEntries :: IO [TimeEntry]
timeEntries = handleProcesses (0, ("", 0)) timeEntry

timeinfos :: IO Times
timeinfos = fmap M.fromList timeEntries

combineTimeInfos :: Times -> Times -> Times
combineTimeInfos !t0 !t1 = M.intersectionWith timeDiff t1 t0
  where timeDiff (n, x1) (_, x0) = (n, x1 - x0)

topTimeProcesses :: Int -> TimesRef -> Float -> IO [TimeInfo]
topTimeProcesses n tref scale = do
  !c1 <- getCurrentTime
  !t1 <- timeinfos
  (t0, c0) <- readIORef tref
  modifyIORef tref (const $! (t1, c1))
  let !ts = M.elems $ combineTimeInfos t0 t1
      !sts = take n $ sortBy (flip (comparing snd)) ts
      !nts = map norm sts
      !scx = (fromRational . toRational $! diffUTCTime c1 c0) * scale / 100
      norm (nm, t) = (nm, min 100 $ t / scx)
  return nts

showTimeInfo :: TimeInfo -> Monitor [String]
showTimeInfo (n, t) = showInfo n (showDigits 1 t) t

runTopCpu :: TimesRef -> Float -> [String] -> Monitor String
runTopCpu tref scale _ = do
   ps <- io $ topTimeProcesses maxProc tref scale
   pstr <- mapM showTimeInfo ps
   parseTemplate $ concat pstr

startTopCpu :: [String] -> Int -> (String -> IO ()) -> IO ()
startTopCpu a r cb = do
  cr <- getSysVar ClockTick
  c <- getCurrentTime
  tref <- newIORef (M.empty, c)
  runM a topCpuConfig (runTopCpu tref (fromIntegral cr)) r cb