Statistics
| Branch: | Tag: | Revision:

root / htools / Ganeti / HTools / Node.hs @ 61bbbed7

History | View | Annotate | Download (20.5 kB)

1
{-| Module describing a node.
2

    
3
    All updates are functional (copy-based) and return a new node with
4
    updated value.
5
-}
6

    
7
{-
8

    
9
Copyright (C) 2009, 2010, 2011 Google Inc.
10

    
11
This program is free software; you can redistribute it and/or modify
12
it under the terms of the GNU General Public License as published by
13
the Free Software Foundation; either version 2 of the License, or
14
(at your option) any later version.
15

    
16
This program is distributed in the hope that it will be useful, but
17
WITHOUT ANY WARRANTY; without even the implied warranty of
18
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19
General Public License for more details.
20

    
21
You should have received a copy of the GNU General Public License
22
along with this program; if not, write to the Free Software
23
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
24
02110-1301, USA.
25

    
26
-}
27

    
28
module Ganeti.HTools.Node
29
    ( Node(..)
30
    , List
31
    -- * Constructor
32
    , create
33
    -- ** Finalization after data loading
34
    , buildPeers
35
    , setIdx
36
    , setAlias
37
    , setOffline
38
    , setXmem
39
    , setFmem
40
    , setPri
41
    , setSec
42
    , setMdsk
43
    , setMcpu
44
    -- * Tag maps
45
    , addTags
46
    , delTags
47
    , rejectAddTags
48
    -- * Instance (re)location
49
    , removePri
50
    , removeSec
51
    , addPri
52
    , addPriEx
53
    , addSec
54
    , addSecEx
55
    -- * Stats
56
    , availDisk
57
    , availMem
58
    , availCpu
59
    , iMem
60
    , iDsk
61
    , conflictingPrimaries
62
    -- * Formatting
63
    , defaultFields
64
    , showHeader
65
    , showField
66
    , list
67
    -- * Misc stuff
68
    , AssocList
69
    , AllocElement
70
    , noSecondary
71
    , computeGroups
72
    ) where
73

    
74
import Data.List hiding (group)
75
import qualified Data.Map as Map
76
import qualified Data.Foldable as Foldable
77
import Data.Ord (comparing)
78
import Text.Printf (printf)
79

    
80
import qualified Ganeti.HTools.Container as Container
81
import qualified Ganeti.HTools.Instance as Instance
82
import qualified Ganeti.HTools.PeerMap as P
83

    
84
import qualified Ganeti.HTools.Types as T
85

    
86
-- * Type declarations
87

    
88
-- | The tag map type.
89
type TagMap = Map.Map String Int
90

    
91
-- | The node type.
92
data Node = Node
93
    { name     :: String    -- ^ The node name
94
    , alias    :: String    -- ^ The shortened name (for display purposes)
95
    , tMem     :: Double    -- ^ Total memory (MiB)
96
    , nMem     :: Int       -- ^ Node memory (MiB)
97
    , fMem     :: Int       -- ^ Free memory (MiB)
98
    , xMem     :: Int       -- ^ Unaccounted memory (MiB)
99
    , tDsk     :: Double    -- ^ Total disk space (MiB)
100
    , fDsk     :: Int       -- ^ Free disk space (MiB)
101
    , tCpu     :: Double    -- ^ Total CPU count
102
    , uCpu     :: Int       -- ^ Used VCPU count
103
    , pList    :: [T.Idx]   -- ^ List of primary instance indices
104
    , sList    :: [T.Idx]   -- ^ List of secondary instance indices
105
    , idx      :: T.Ndx     -- ^ Internal index for book-keeping
106
    , peers    :: P.PeerMap -- ^ Pnode to instance mapping
107
    , failN1   :: Bool      -- ^ Whether the node has failed n1
108
    , rMem     :: Int       -- ^ Maximum memory needed for failover by
109
                            -- primaries of this node
110
    , pMem     :: Double    -- ^ Percent of free memory
111
    , pDsk     :: Double    -- ^ Percent of free disk
112
    , pRem     :: Double    -- ^ Percent of reserved memory
113
    , pCpu     :: Double    -- ^ Ratio of virtual to physical CPUs
114
    , mDsk     :: Double    -- ^ Minimum free disk ratio
115
    , mCpu     :: Double    -- ^ Max ratio of virt-to-phys CPUs
116
    , loDsk    :: Int       -- ^ Autocomputed from mDsk low disk
117
                            -- threshold
118
    , hiCpu    :: Int       -- ^ Autocomputed from mCpu high cpu
119
                            -- threshold
120
    , offline  :: Bool      -- ^ Whether the node should not be used
121
                            -- for allocations and skipped from score
122
                            -- computations
123
    , utilPool :: T.DynUtil -- ^ Total utilisation capacity
124
    , utilLoad :: T.DynUtil -- ^ Sum of instance utilisation
125
    , pTags    :: TagMap    -- ^ Map of primary instance tags and their count
126
    , group    :: T.Gdx     -- ^ The node's group (index)
127
    } deriving (Show, Read, Eq)
128

    
129
instance T.Element Node where
130
    nameOf = name
131
    idxOf = idx
132
    setAlias = setAlias
133
    setIdx = setIdx
134
    allNames n = [name n, alias n]
135

    
136
-- | A simple name for the int, node association list.
137
type AssocList = [(T.Ndx, Node)]
138

    
139
-- | A simple name for a node map.
140
type List = Container.Container Node
141

    
142
-- | A simple name for an allocation element (here just for logistic
143
-- reasons).
144
type AllocElement = (List, Instance.Instance, [Node], T.Score)
145

    
146
-- | Constant node index for a non-moveable instance.
147
noSecondary :: T.Ndx
148
noSecondary = -1
149

    
150
-- * Helper functions
151

    
152
-- | Add a tag to a tagmap.
153
addTag :: TagMap -> String -> TagMap
154
addTag t s = Map.insertWith (+) s 1 t
155

    
156
-- | Add multiple tags.
157
addTags :: TagMap -> [String] -> TagMap
158
addTags = foldl' addTag
159

    
160
-- | Adjust or delete a tag from a tagmap.
161
delTag :: TagMap -> String -> TagMap
162
delTag t s = Map.update (\v -> if v > 1
163
                               then Just (v-1)
164
                               else Nothing)
165
             s t
166

    
167
-- | Remove multiple tags.
168
delTags :: TagMap -> [String] -> TagMap
169
delTags = foldl' delTag
170

    
171
-- | Check if we can add a list of tags to a tagmap.
172
rejectAddTags :: TagMap -> [String] -> Bool
173
rejectAddTags t = any (`Map.member` t)
174

    
175
-- | Check how many primary instances have conflicting tags. The
176
-- algorithm to compute this is to sum the count of all tags, then
177
-- subtract the size of the tag map (since each tag has at least one,
178
-- non-conflicting instance); this is equivalent to summing the
179
-- values in the tag map minus one.
180
conflictingPrimaries :: Node -> Int
181
conflictingPrimaries (Node { pTags = t }) = Foldable.sum t - Map.size t
182

    
183
-- * Initialization functions
184

    
185
-- | Create a new node.
186
--
187
-- The index and the peers maps are empty, and will be need to be
188
-- update later via the 'setIdx' and 'buildPeers' functions.
189
create :: String -> Double -> Int -> Int -> Double
190
       -> Int -> Double -> Bool -> T.Gdx -> Node
191
create name_init mem_t_init mem_n_init mem_f_init
192
       dsk_t_init dsk_f_init cpu_t_init offline_init group_init =
193
    Node { name = name_init
194
         , alias = name_init
195
         , tMem = mem_t_init
196
         , nMem = mem_n_init
197
         , fMem = mem_f_init
198
         , tDsk = dsk_t_init
199
         , fDsk = dsk_f_init
200
         , tCpu = cpu_t_init
201
         , uCpu = 0
202
         , pList = []
203
         , sList = []
204
         , failN1 = True
205
         , idx = -1
206
         , peers = P.empty
207
         , rMem = 0
208
         , pMem = fromIntegral mem_f_init / mem_t_init
209
         , pDsk = fromIntegral dsk_f_init / dsk_t_init
210
         , pRem = 0
211
         , pCpu = 0
212
         , offline = offline_init
213
         , xMem = 0
214
         , mDsk = T.defReservedDiskRatio
215
         , mCpu = T.defVcpuRatio
216
         , loDsk = mDskToloDsk T.defReservedDiskRatio dsk_t_init
217
         , hiCpu = mCpuTohiCpu T.defVcpuRatio cpu_t_init
218
         , utilPool = T.baseUtil
219
         , utilLoad = T.zeroUtil
220
         , pTags = Map.empty
221
         , group = group_init
222
         }
223

    
224
-- | Conversion formula from mDsk\/tDsk to loDsk.
225
mDskToloDsk :: Double -> Double -> Int
226
mDskToloDsk mval = floor . (mval *)
227

    
228
-- | Conversion formula from mCpu\/tCpu to hiCpu.
229
mCpuTohiCpu :: Double -> Double -> Int
230
mCpuTohiCpu mval = floor . (mval *)
231

    
232
-- | Changes the index.
233
--
234
-- This is used only during the building of the data structures.
235
setIdx :: Node -> T.Ndx -> Node
236
setIdx t i = t {idx = i}
237

    
238
-- | Changes the alias.
239
--
240
-- This is used only during the building of the data structures.
241
setAlias :: Node -> String -> Node
242
setAlias t s = t { alias = s }
243

    
244
-- | Sets the offline attribute.
245
setOffline :: Node -> Bool -> Node
246
setOffline t val = t { offline = val }
247

    
248
-- | Sets the unnaccounted memory.
249
setXmem :: Node -> Int -> Node
250
setXmem t val = t { xMem = val }
251

    
252
-- | Sets the max disk usage ratio.
253
setMdsk :: Node -> Double -> Node
254
setMdsk t val = t { mDsk = val, loDsk = mDskToloDsk val (tDsk t) }
255

    
256
-- | Sets the max cpu usage ratio.
257
setMcpu :: Node -> Double -> Node
258
setMcpu t val = t { mCpu = val, hiCpu = mCpuTohiCpu val (tCpu t) }
259

    
260
-- | Computes the maximum reserved memory for peers from a peer map.
261
computeMaxRes :: P.PeerMap -> P.Elem
262
computeMaxRes = P.maxElem
263

    
264
-- | Builds the peer map for a given node.
265
buildPeers :: Node -> Instance.List -> Node
266
buildPeers t il =
267
    let mdata = map
268
                (\i_idx -> let inst = Container.find i_idx il
269
                               mem = if Instance.autoBalance inst
270
                                     then Instance.mem inst
271
                                     else 0
272
                           in (Instance.pNode inst, mem))
273
                (sList t)
274
        pmap = P.accumArray (+) mdata
275
        new_rmem = computeMaxRes pmap
276
        new_failN1 = fMem t <= new_rmem
277
        new_prem = fromIntegral new_rmem / tMem t
278
    in t {peers=pmap, failN1 = new_failN1, rMem = new_rmem, pRem = new_prem}
279

    
280
-- | Assigns an instance to a node as primary and update the used VCPU
281
-- count, utilisation data and tags map.
282
setPri :: Node -> Instance.Instance -> Node
283
setPri t inst = t { pList = Instance.idx inst:pList t
284
                  , uCpu = new_count
285
                  , pCpu = fromIntegral new_count / tCpu t
286
                  , utilLoad = utilLoad t `T.addUtil` Instance.util inst
287
                  , pTags = addTags (pTags t) (Instance.tags inst)
288
                  }
289
    where new_count = uCpu t + Instance.vcpus inst
290

    
291
-- | Assigns an instance to a node as secondary without other updates.
292
setSec :: Node -> Instance.Instance -> Node
293
setSec t inst = t { sList = Instance.idx inst:sList t
294
                  , utilLoad = old_load { T.dskWeight = T.dskWeight old_load +
295
                                          T.dskWeight (Instance.util inst) }
296
                  }
297
    where old_load = utilLoad t
298

    
299
-- * Update functions
300

    
301
-- | Sets the free memory.
302
setFmem :: Node -> Int -> Node
303
setFmem t new_mem =
304
    let new_n1 = new_mem <= rMem t
305
        new_mp = fromIntegral new_mem / tMem t
306
    in t { fMem = new_mem, failN1 = new_n1, pMem = new_mp }
307

    
308
-- | Removes a primary instance.
309
removePri :: Node -> Instance.Instance -> Node
310
removePri t inst =
311
    let iname = Instance.idx inst
312
        new_plist = delete iname (pList t)
313
        new_mem = Instance.applyIfOnline inst (+ Instance.mem inst) (fMem t)
314
        new_dsk = fDsk t + Instance.dsk inst
315
        new_mp = fromIntegral new_mem / tMem t
316
        new_dp = fromIntegral new_dsk / tDsk t
317
        new_failn1 = new_mem <= rMem t
318
        new_ucpu = Instance.applyIfOnline inst
319
                   (\x -> x - Instance.vcpus inst) (uCpu t)
320
        new_rcpu = fromIntegral new_ucpu / tCpu t
321
        new_load = utilLoad t `T.subUtil` Instance.util inst
322
    in t { pList = new_plist, fMem = new_mem, fDsk = new_dsk
323
         , failN1 = new_failn1, pMem = new_mp, pDsk = new_dp
324
         , uCpu = new_ucpu, pCpu = new_rcpu, utilLoad = new_load
325
         , pTags = delTags (pTags t) (Instance.tags inst) }
326

    
327
-- | Removes a secondary instance.
328
removeSec :: Node -> Instance.Instance -> Node
329
removeSec t inst =
330
    let iname = Instance.idx inst
331
        uses_disk = Instance.usesLocalStorage inst
332
        cur_dsk = fDsk t
333
        pnode = Instance.pNode inst
334
        new_slist = delete iname (sList t)
335
        new_dsk = if uses_disk
336
                  then cur_dsk + Instance.dsk inst
337
                  else cur_dsk
338
        old_peers = peers t
339
        old_peem = P.find pnode old_peers
340
        new_peem =  if Instance.autoBalance inst
341
                    then old_peem - Instance.mem inst
342
                    else old_peem
343
        new_peers = if new_peem > 0
344
                    then P.add pnode new_peem old_peers
345
                    else P.remove pnode old_peers
346
        old_rmem = rMem t
347
        new_rmem = if old_peem < old_rmem
348
                   then old_rmem
349
                   else computeMaxRes new_peers
350
        new_prem = fromIntegral new_rmem / tMem t
351
        new_failn1 = fMem t <= new_rmem
352
        new_dp = fromIntegral new_dsk / tDsk t
353
        old_load = utilLoad t
354
        new_load = old_load { T.dskWeight = T.dskWeight old_load -
355
                                            T.dskWeight (Instance.util inst) }
356
    in t { sList = new_slist, fDsk = new_dsk, peers = new_peers
357
         , failN1 = new_failn1, rMem = new_rmem, pDsk = new_dp
358
         , pRem = new_prem, utilLoad = new_load }
359

    
360
-- | Adds a primary instance (basic version).
361
addPri :: Node -> Instance.Instance -> T.OpResult Node
362
addPri = addPriEx False
363

    
364
-- | Adds a primary instance (extended version).
365
addPriEx :: Bool               -- ^ Whether to override the N+1 and
366
                               -- other /soft/ checks, useful if we
367
                               -- come from a worse status
368
                               -- (e.g. offline)
369
         -> Node               -- ^ The target node
370
         -> Instance.Instance  -- ^ The instance to add
371
         -> T.OpResult Node    -- ^ The result of the operation,
372
                               -- either the new version of the node
373
                               -- or a failure mode
374
addPriEx force t inst =
375
    let iname = Instance.idx inst
376
        uses_disk = Instance.usesLocalStorage inst
377
        cur_dsk = fDsk t
378
        new_mem = Instance.applyIfOnline inst
379
                  (\x -> x - Instance.mem inst) (fMem t)
380
        new_dsk = if uses_disk
381
                  then cur_dsk - Instance.dsk inst
382
                  else cur_dsk
383
        new_failn1 = new_mem <= rMem t
384
        new_ucpu = Instance.applyIfOnline inst (+ Instance.vcpus inst) (uCpu t)
385
        new_pcpu = fromIntegral new_ucpu / tCpu t
386
        new_dp = fromIntegral new_dsk / tDsk t
387
        l_cpu = mCpu t
388
        new_load = utilLoad t `T.addUtil` Instance.util inst
389
        inst_tags = Instance.tags inst
390
        old_tags = pTags t
391
        strict = not force
392
    in case () of
393
         _ | new_mem <= 0 -> T.OpFail T.FailMem
394
           | uses_disk && new_dsk <= 0 -> T.OpFail T.FailDisk
395
           | uses_disk && mDsk t > new_dp && strict -> T.OpFail T.FailDisk
396
           | new_failn1 && not (failN1 t) && strict -> T.OpFail T.FailMem
397
           | l_cpu >= 0 && l_cpu < new_pcpu && strict -> T.OpFail T.FailCPU
398
           | rejectAddTags old_tags inst_tags -> T.OpFail T.FailTags
399
           | otherwise ->
400
               let new_plist = iname:pList t
401
                   new_mp = fromIntegral new_mem / tMem t
402
                   r = t { pList = new_plist, fMem = new_mem, fDsk = new_dsk
403
                         , failN1 = new_failn1, pMem = new_mp, pDsk = new_dp
404
                         , uCpu = new_ucpu, pCpu = new_pcpu
405
                         , utilLoad = new_load
406
                         , pTags = addTags old_tags inst_tags }
407
               in T.OpGood r
408

    
409
-- | Adds a secondary instance (basic version).
410
addSec :: Node -> Instance.Instance -> T.Ndx -> T.OpResult Node
411
addSec = addSecEx False
412

    
413
-- | Adds a secondary instance (extended version).
414
addSecEx :: Bool -> Node -> Instance.Instance -> T.Ndx -> T.OpResult Node
415
addSecEx force t inst pdx =
416
    let iname = Instance.idx inst
417
        old_peers = peers t
418
        old_mem = fMem t
419
        new_dsk = fDsk t - Instance.dsk inst
420
        secondary_needed_mem = if Instance.autoBalance inst &&
421
                                  not (Instance.instanceOffline inst)
422
                               then Instance.mem inst
423
                               else 0
424
        new_peem = P.find pdx old_peers + secondary_needed_mem
425
        new_peers = P.add pdx new_peem old_peers
426
        new_rmem = max (rMem t) new_peem
427
        new_prem = fromIntegral new_rmem / tMem t
428
        new_failn1 = old_mem <= new_rmem
429
        new_dp = fromIntegral new_dsk / tDsk t
430
        old_load = utilLoad t
431
        new_load = old_load { T.dskWeight = T.dskWeight old_load +
432
                                            T.dskWeight (Instance.util inst) }
433
        strict = not force
434
    in case () of
435
         _ | not (Instance.hasSecondary inst) -> T.OpFail T.FailDisk
436
           | new_dsk <= 0 -> T.OpFail T.FailDisk
437
           | mDsk t > new_dp && strict -> T.OpFail T.FailDisk
438
           | secondary_needed_mem >= old_mem && strict -> T.OpFail T.FailMem
439
           | new_failn1 && not (failN1 t) && strict -> T.OpFail T.FailMem
440
           | otherwise ->
441
               let new_slist = iname:sList t
442
                   r = t { sList = new_slist, fDsk = new_dsk
443
                         , peers = new_peers, failN1 = new_failn1
444
                         , rMem = new_rmem, pDsk = new_dp
445
                         , pRem = new_prem, utilLoad = new_load }
446
               in T.OpGood r
447

    
448
-- * Stats functions
449

    
450
-- | Computes the amount of available disk on a given node.
451
availDisk :: Node -> Int
452
availDisk t =
453
    let _f = fDsk t
454
        _l = loDsk t
455
    in if _f < _l
456
       then 0
457
       else _f - _l
458

    
459
-- | Computes the amount of used disk on a given node.
460
iDsk :: Node -> Int
461
iDsk t = truncate (tDsk t) - fDsk t
462

    
463
-- | Computes the amount of available memory on a given node.
464
availMem :: Node -> Int
465
availMem t =
466
    let _f = fMem t
467
        _l = rMem t
468
    in if _f < _l
469
       then 0
470
       else _f - _l
471

    
472
-- | Computes the amount of available memory on a given node.
473
availCpu :: Node -> Int
474
availCpu t =
475
    let _u = uCpu t
476
        _l = hiCpu t
477
    in if _l >= _u
478
       then _l - _u
479
       else 0
480

    
481
-- | The memory used by instances on a given node.
482
iMem :: Node -> Int
483
iMem t = truncate (tMem t) - nMem t - xMem t - fMem t
484

    
485
-- * Display functions
486

    
487
-- | Return a field for a given node.
488
showField :: Node   -- ^ Node which we're querying
489
          -> String -- ^ Field name
490
          -> String -- ^ Field value as string
491
showField t field =
492
    case field of
493
      "idx"  -> printf "%4d" $ idx t
494
      "name" -> alias t
495
      "fqdn" -> name t
496
      "status" -> case () of
497
                    _ | offline t -> "-"
498
                      | failN1 t -> "*"
499
                      | otherwise -> " "
500
      "tmem" -> printf "%5.0f" $ tMem t
501
      "nmem" -> printf "%5d" $ nMem t
502
      "xmem" -> printf "%5d" $ xMem t
503
      "fmem" -> printf "%5d" $ fMem t
504
      "imem" -> printf "%5d" $ iMem t
505
      "rmem" -> printf "%5d" $ rMem t
506
      "amem" -> printf "%5d" $ fMem t - rMem t
507
      "tdsk" -> printf "%5.0f" $ tDsk t / 1024
508
      "fdsk" -> printf "%5d" $ fDsk t `div` 1024
509
      "tcpu" -> printf "%4.0f" $ tCpu t
510
      "ucpu" -> printf "%4d" $ uCpu t
511
      "pcnt" -> printf "%3d" $ length (pList t)
512
      "scnt" -> printf "%3d" $ length (sList t)
513
      "plist" -> show $ pList t
514
      "slist" -> show $ sList t
515
      "pfmem" -> printf "%6.4f" $ pMem t
516
      "pfdsk" -> printf "%6.4f" $ pDsk t
517
      "rcpu"  -> printf "%5.2f" $ pCpu t
518
      "cload" -> printf "%5.3f" uC
519
      "mload" -> printf "%5.3f" uM
520
      "dload" -> printf "%5.3f" uD
521
      "nload" -> printf "%5.3f" uN
522
      "ptags" -> intercalate "," . map (uncurry (printf "%s=%d")) .
523
                 Map.toList $ pTags t
524
      "peermap" -> show $ peers t
525
      _ -> T.unknownField
526
    where
527
      T.DynUtil { T.cpuWeight = uC, T.memWeight = uM,
528
                  T.dskWeight = uD, T.netWeight = uN } = utilLoad t
529

    
530
-- | Returns the header and numeric propery of a field.
531
showHeader :: String -> (String, Bool)
532
showHeader field =
533
    case field of
534
      "idx" -> ("Index", True)
535
      "name" -> ("Name", False)
536
      "fqdn" -> ("Name", False)
537
      "status" -> ("F", False)
538
      "tmem" -> ("t_mem", True)
539
      "nmem" -> ("n_mem", True)
540
      "xmem" -> ("x_mem", True)
541
      "fmem" -> ("f_mem", True)
542
      "imem" -> ("i_mem", True)
543
      "rmem" -> ("r_mem", True)
544
      "amem" -> ("a_mem", True)
545
      "tdsk" -> ("t_dsk", True)
546
      "fdsk" -> ("f_dsk", True)
547
      "tcpu" -> ("pcpu", True)
548
      "ucpu" -> ("vcpu", True)
549
      "pcnt" -> ("pcnt", True)
550
      "scnt" -> ("scnt", True)
551
      "plist" -> ("primaries", True)
552
      "slist" -> ("secondaries", True)
553
      "pfmem" -> ("p_fmem", True)
554
      "pfdsk" -> ("p_fdsk", True)
555
      "rcpu"  -> ("r_cpu", True)
556
      "cload" -> ("lCpu", True)
557
      "mload" -> ("lMem", True)
558
      "dload" -> ("lDsk", True)
559
      "nload" -> ("lNet", True)
560
      "ptags" -> ("PrimaryTags", False)
561
      "peermap" -> ("PeerMap", False)
562
      -- TODO: add node fields (group.uuid, group)
563
      _ -> (T.unknownField, False)
564

    
565
-- | String converter for the node list functionality.
566
list :: [String] -> Node -> [String]
567
list fields t = map (showField t) fields
568

    
569

    
570
-- | Constant holding the fields we're displaying by default.
571
defaultFields :: [String]
572
defaultFields =
573
    [ "status", "name", "tmem", "nmem", "imem", "xmem", "fmem"
574
    , "rmem", "tdsk", "fdsk", "tcpu", "ucpu", "pcnt", "scnt"
575
    , "pfmem", "pfdsk", "rcpu"
576
    , "cload", "mload", "dload", "nload" ]
577

    
578
-- | Split a list of nodes into a list of (node group UUID, list of
579
-- associated nodes).
580
computeGroups :: [Node] -> [(T.Gdx, [Node])]
581
computeGroups nodes =
582
  let nodes' = sortBy (comparing group) nodes
583
      nodes'' = groupBy (\a b -> group a == group b) nodes'
584
  in map (\nl -> (group (head nl), nl)) nodes''