diff --git a/Ganeti/HTools/Cluster.hs b/Ganeti/HTools/Cluster.hs
index dcae7809dd31e4796e3ca3cda6dcb87904ad80ab..6e27c9198b5c68604f0c52f2c716c92df3fc1cfa 100644
--- a/Ganeti/HTools/Cluster.hs
+++ b/Ganeti/HTools/Cluster.hs
@@ -120,7 +120,7 @@ computeBadItems nl il =
   let bad_nodes = verifyN1 $ getOnline nl
       bad_instances = map (\idx -> Container.find idx il) .
                       sort . nub $
-                      concatMap (\ n -> Node.slist n ++ Node.plist n) bad_nodes
+                      concatMap (\ n -> Node.sList n ++ Node.pList n) bad_nodes
   in
     (bad_nodes, bad_instances)
 
@@ -155,16 +155,16 @@ updateCStats cs node =
                  cs_xmem = x_xmem, cs_nmem = x_nmem, cs_ninst = x_ninst
                }
             = cs
-        inc_amem = Node.f_mem node - Node.r_mem node
+        inc_amem = Node.fMem node - Node.rMem node
         inc_amem' = if inc_amem > 0 then inc_amem else 0
         inc_adsk = Node.availDisk node
-        inc_imem = truncate (Node.t_mem node) - Node.n_mem node
-                   - Node.x_mem node - Node.f_mem node
-        inc_icpu = Node.u_cpu node
-        inc_idsk = truncate (Node.t_dsk node) - Node.f_dsk node
+        inc_imem = truncate (Node.tMem node) - Node.nMem node
+                   - Node.xMem node - Node.fMem node
+        inc_icpu = Node.uCpu node
+        inc_idsk = truncate (Node.tDsk node) - Node.fDsk node
 
-    in cs { cs_fmem = x_fmem + Node.f_mem node
-          , cs_fdsk = x_fdsk + Node.f_dsk node
+    in cs { cs_fmem = x_fmem + Node.fMem node
+          , cs_fdsk = x_fdsk + Node.fDsk node
           , cs_amem = x_amem + inc_amem'
           , cs_adsk = x_adsk + inc_adsk
           , cs_acpu = x_acpu
@@ -174,12 +174,12 @@ updateCStats cs node =
           , cs_imem = x_imem + inc_imem
           , cs_idsk = x_idsk + inc_idsk
           , cs_icpu = x_icpu + inc_icpu
-          , cs_tmem = x_tmem + Node.t_mem node
-          , cs_tdsk = x_tdsk + Node.t_dsk node
-          , cs_tcpu = x_tcpu + Node.t_cpu node
-          , cs_xmem = x_xmem + Node.x_mem node
-          , cs_nmem = x_nmem + Node.n_mem node
-          , cs_ninst = x_ninst + length (Node.plist node)
+          , cs_tmem = x_tmem + Node.tMem node
+          , cs_tdsk = x_tdsk + Node.tDsk node
+          , cs_tcpu = x_tcpu + Node.tCpu node
+          , cs_xmem = x_xmem + Node.xMem node
+          , cs_nmem = x_nmem + Node.nMem node
+          , cs_ninst = x_ninst + length (Node.pList node)
           }
 
 -- | Compute the total free disk and memory in the cluster.
@@ -204,24 +204,24 @@ compDetailedCV nl =
     let
         all_nodes = Container.elems nl
         (offline, nodes) = partition Node.offline all_nodes
-        mem_l = map Node.p_mem nodes
-        dsk_l = map Node.p_dsk nodes
+        mem_l = map Node.pMem nodes
+        dsk_l = map Node.pDsk nodes
         mem_cv = varianceCoeff mem_l
         dsk_cv = varianceCoeff dsk_l
         n1_l = length $ filter Node.failN1 nodes
         n1_score = fromIntegral n1_l /
                    fromIntegral (length nodes)::Double
-        res_l = map Node.p_rem nodes
+        res_l = map Node.pRem nodes
         res_cv = varianceCoeff res_l
-        offline_inst = sum . map (\n -> (length . Node.plist $ n) +
-                                        (length . Node.slist $ n)) $ offline
-        online_inst = sum . map (\n -> (length . Node.plist $ n) +
-                                       (length . Node.slist $ n)) $ nodes
+        offline_inst = sum . map (\n -> (length . Node.pList $ n) +
+                                        (length . Node.sList $ n)) $ offline
+        online_inst = sum . map (\n -> (length . Node.pList $ n) +
+                                       (length . Node.sList $ n)) $ nodes
         off_score = if offline_inst == 0
                     then 0::Double
                     else fromIntegral offline_inst /
                          fromIntegral (offline_inst + online_inst)::Double
-        cpu_l = map Node.p_cpu nodes
+        cpu_l = map Node.pCpu nodes
         cpu_cv = varianceCoeff cpu_l
     in [mem_cv, dsk_cv, n1_score, res_cv, off_score, cpu_cv]
 
@@ -245,8 +245,8 @@ applyMove :: Node.List -> Instance.Instance
           -> IMove -> OpResult (Node.List, Instance.Instance, Ndx, Ndx)
 -- Failover (f)
 applyMove nl inst Failover =
-    let old_pdx = Instance.pnode inst
-        old_sdx = Instance.snode inst
+    let old_pdx = Instance.pNode inst
+        old_sdx = Instance.sNode inst
         old_p = Container.find old_pdx nl
         old_s = Container.find old_sdx nl
         int_p = Node.removePri old_p inst
@@ -261,8 +261,8 @@ applyMove nl inst Failover =
 
 -- Replace the primary (f:, r:np, f)
 applyMove nl inst (ReplacePrimary new_pdx) =
-    let old_pdx = Instance.pnode inst
-        old_sdx = Instance.snode inst
+    let old_pdx = Instance.pNode inst
+        old_sdx = Instance.sNode inst
         old_p = Container.find old_pdx nl
         old_s = Container.find old_sdx nl
         tgt_n = Container.find new_pdx nl
@@ -283,8 +283,8 @@ applyMove nl inst (ReplacePrimary new_pdx) =
 
 -- Replace the secondary (r:ns)
 applyMove nl inst (ReplaceSecondary new_sdx) =
-    let old_pdx = Instance.pnode inst
-        old_sdx = Instance.snode inst
+    let old_pdx = Instance.pNode inst
+        old_sdx = Instance.sNode inst
         old_s = Container.find old_sdx nl
         tgt_n = Container.find new_sdx nl
         int_s = Node.removeSec old_s inst
@@ -297,8 +297,8 @@ applyMove nl inst (ReplaceSecondary new_sdx) =
 
 -- Replace the secondary and failover (r:np, f)
 applyMove nl inst (ReplaceAndFailover new_pdx) =
-    let old_pdx = Instance.pnode inst
-        old_sdx = Instance.snode inst
+    let old_pdx = Instance.pNode inst
+        old_sdx = Instance.sNode inst
         old_p = Container.find old_pdx nl
         old_s = Container.find old_sdx nl
         tgt_n = Container.find new_pdx nl
@@ -315,8 +315,8 @@ applyMove nl inst (ReplaceAndFailover new_pdx) =
 
 -- Failver and replace the secondary (f, r:ns)
 applyMove nl inst (FailoverAndReplace new_sdx) =
-    let old_pdx = Instance.pnode inst
-        old_sdx = Instance.snode inst
+    let old_pdx = Instance.pNode inst
+        old_sdx = Instance.sNode inst
         old_p = Container.find old_pdx nl
         old_s = Container.find old_sdx nl
         tgt_n = Container.find new_sdx nl
@@ -402,8 +402,8 @@ checkInstanceMove :: [Ndx]             -- ^ Allowed target node indices
                   -> Table             -- ^ Best new table for this instance
 checkInstanceMove nodes_idx disk_moves ini_tbl target =
     let
-        opdx = Instance.pnode target
-        osdx = Instance.snode target
+        opdx = Instance.pNode target
+        osdx = Instance.sNode target
         nodes = filter (\idx -> idx /= opdx && idx /= osdx) nodes_idx
         use_secondary = elem osdx nodes_idx
         aft_failover = if use_secondary -- if allowed to failover
@@ -428,7 +428,7 @@ checkMove nodes_idx disk_moves ini_tbl victims =
         best_tbl =
             foldl'
             (\ step_tbl em ->
-                 if Instance.snode em == Node.noSecondary then step_tbl
+                 if Instance.sNode em == Node.noSecondary then step_tbl
                     else compareTables step_tbl $
                          checkInstanceMove nodes_idx disk_moves ini_tbl em)
             ini_tbl victims
@@ -531,7 +531,7 @@ tryReloc :: (Monad m) =>
 tryReloc nl il xid 1 ex_idx =
     let all_nodes = getOnline nl
         inst = Container.find xid il
-        ex_idx' = Instance.pnode inst:ex_idx
+        ex_idx' = Instance.pNode inst:ex_idx
         valid_nodes = filter (not . flip elem ex_idx' . Node.idx) all_nodes
         valid_idxes = map Node.idx valid_nodes
         sols1 = foldl' (\cstate x ->
@@ -603,8 +603,8 @@ printSolutionLine nl il nmlen imlen plc pos =
         inam = Instance.name inst
         npri = Container.nameOf nl p
         nsec = Container.nameOf nl s
-        opri = Container.nameOf nl $ Instance.pnode inst
-        osec = Container.nameOf nl $ Instance.snode inst
+        opri = Container.nameOf nl $ Instance.pNode inst
+        osec = Container.nameOf nl $ Instance.sNode inst
         (moves, cmds) =  computeMoves inst inam opri osec npri nsec
         ostr = printf "%s:%s" opri osec::String
         nstr = printf "%s:%s" npri nsec::String
@@ -619,8 +619,8 @@ involvedNodes :: Instance.List -> Placement -> [Ndx]
 involvedNodes il plc =
     let (i, np, ns, _, _) = plc
         inst = Container.find i il
-        op = Instance.pnode inst
-        os = Instance.snode inst
+        op = Instance.pNode inst
+        os = Instance.sNode inst
     in nub [np, ns, op, os]
 
 -- | Inner function for splitJobs, that either appends the next job to
diff --git a/Ganeti/HTools/Instance.hs b/Ganeti/HTools/Instance.hs
index 78393454f3b4452f34bf9392afca83c6208e37c5..b898e61389d4855591ba29fe024f5aebda96ab88 100644
--- a/Ganeti/HTools/Instance.hs
+++ b/Ganeti/HTools/Instance.hs
@@ -40,9 +40,9 @@ data Instance = Instance { name :: String   -- ^ The instance name
                          , vcpus :: Int     -- ^ Number of VCPUs
                          , running :: Bool  -- ^ Whether the instance
                                             -- is running
-                         , run_st :: String -- ^ Original (text) run status
-                         , pnode :: T.Ndx   -- ^ Original primary node
-                         , snode :: T.Ndx   -- ^ Original secondary node
+                         , runSt :: String  -- ^ Original (text) run status
+                         , pNode :: T.Ndx   -- ^ Original primary node
+                         , sNode :: T.Ndx   -- ^ Original secondary node
                          , idx :: T.Idx     -- ^ Internal index for
                                             -- book-keeping
                          } deriving (Show)
@@ -76,9 +76,9 @@ create name_init mem_init dsk_init vcpus_init run_init pn sn =
                       "running" -> True
                       "ERROR_up" -> True
                       _ -> False,
-          run_st = run_init,
-          pnode = pn,
-          snode = sn,
+          runSt = run_init,
+          pNode = pn,
+          sNode = sn,
           idx = -1
         }
 
@@ -104,17 +104,17 @@ setName t s = t { name = s }
 setPri :: Instance  -- ^ the original instance
         -> T.Ndx    -- ^ the new primary node
         -> Instance -- ^ the modified instance
-setPri t p = t { pnode = p }
+setPri t p = t { pNode = p }
 
 -- | Changes the secondary node of the instance.
 setSec :: Instance  -- ^ the original instance
         -> T.Ndx    -- ^ the new secondary node
         -> Instance -- ^ the modified instance
-setSec t s = t { snode = s }
+setSec t s = t { sNode = s }
 
 -- | Changes both nodes of the instance.
 setBoth :: Instance  -- ^ the original instance
          -> T.Ndx    -- ^ new primary node index
          -> T.Ndx    -- ^ new secondary node index
          -> Instance -- ^ the modified instance
-setBoth t p s = t { pnode = p, snode = s }
+setBoth t p s = t { pNode = p, sNode = s }
diff --git a/Ganeti/HTools/Loader.hs b/Ganeti/HTools/Loader.hs
index 0e5a4c501c7625ad05dcc8bcb71a78d2e018f91c..fd39461bb25c8bd56e8a3e776250ff884a8f0a4c 100644
--- a/Ganeti/HTools/Loader.hs
+++ b/Ganeti/HTools/Loader.hs
@@ -100,8 +100,8 @@ fixNodes :: [(Ndx, Node.Node)]
          -> [(Ndx, Node.Node)]
 fixNodes accu (idx, inst) =
     let
-        pdx = Instance.pnode inst
-        sdx = Instance.snode inst
+        pdx = Instance.pNode inst
+        sdx = Instance.sNode inst
         pold = fromJust $ lookup pdx accu
         pnew = Node.setPri pold idx
         pnew' = Node.addCpus pnew (Instance.vcpus inst)
@@ -156,19 +156,19 @@ checkData nl il =
     Container.mapAccum
         (\ msgs node ->
              let nname = Node.name node
-                 nilst = map (flip Container.find il) (Node.plist node)
+                 nilst = map (flip Container.find il) (Node.pList node)
                  dilst = filter (not . Instance.running) nilst
                  adj_mem = sum . map Instance.mem $ dilst
-                 delta_mem = truncate (Node.t_mem node)
-                             - Node.n_mem node
-                             - Node.f_mem node
+                 delta_mem = truncate (Node.tMem node)
+                             - Node.nMem node
+                             - Node.fMem node
                              - nodeImem node il
                              + adj_mem
-                 delta_dsk = truncate (Node.t_dsk node)
-                             - Node.f_dsk node
+                 delta_dsk = truncate (Node.tDsk node)
+                             - Node.fDsk node
                              - nodeIdsk node il
                  newn = Node.setFmem (Node.setXmem node delta_mem)
-                        (Node.f_mem node - adj_mem)
+                        (Node.fMem node - adj_mem)
                  umsg1 = [printf "node %s is missing %d MB ram \
                                  \and %d GB disk"
                                  nname delta_mem (delta_dsk `div` 1024) |
@@ -181,7 +181,7 @@ nodeImem :: Node.Node -> Instance.List -> Int
 nodeImem node il =
     let rfind = flip Container.find il
     in sum . map (Instance.mem . rfind)
-           $ Node.plist node
+           $ Node.pList node
 
 -- | Compute the amount of disk used by instances on a node (either primary
 -- or secondary).
@@ -189,4 +189,4 @@ nodeIdsk :: Node.Node -> Instance.List -> Int
 nodeIdsk node il =
     let rfind = flip Container.find il
     in sum . map (Instance.dsk . rfind)
-           $ Node.plist node ++ Node.slist node
+           $ Node.pList node ++ Node.sList node
diff --git a/Ganeti/HTools/Node.hs b/Ganeti/HTools/Node.hs
index dad11bdaf8ac3df27155753126d2df3841ac97d8..96db0ceaf0c14c955093052f5e258bdd953b11ba 100644
--- a/Ganeti/HTools/Node.hs
+++ b/Ganeti/HTools/Node.hs
@@ -27,12 +27,12 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 
 module Ganeti.HTools.Node
     ( Node(failN1, name, idx,
-           t_mem, n_mem, f_mem, r_mem, x_mem,
-           t_dsk, f_dsk,
-           t_cpu, u_cpu,
-           p_mem, p_dsk, p_rem, p_cpu,
-           m_dsk, m_cpu, lo_dsk, hi_cpu,
-           plist, slist, offline)
+           tMem, nMem, fMem, rMem, xMem,
+           tDsk, fDsk,
+           tCpu, uCpu,
+           pMem, pDsk, pRem, pCpu,
+           mDsk, mCpu, loDsk, hiCpu,
+           pList, sList, offline)
     , List
     -- * Constructor
     , create
@@ -75,30 +75,30 @@ import qualified Ganeti.HTools.Types as T
 
 -- | The node type.
 data Node = Node { name  :: String -- ^ The node name
-                 , t_mem :: Double -- ^ Total memory (MiB)
-                 , n_mem :: Int    -- ^ Node memory (MiB)
-                 , f_mem :: Int    -- ^ Free memory (MiB)
-                 , x_mem :: Int    -- ^ Unaccounted memory (MiB)
-                 , t_dsk :: Double -- ^ Total disk space (MiB)
-                 , f_dsk :: Int    -- ^ Free disk space (MiB)
-                 , t_cpu :: Double -- ^ Total CPU count
-                 , u_cpu :: Int    -- ^ Used VCPU count
-                 , plist :: [T.Idx]-- ^ List of primary instance indices
-                 , slist :: [T.Idx]-- ^ List of secondary instance indices
+                 , tMem :: Double  -- ^ Total memory (MiB)
+                 , nMem :: Int     -- ^ Node memory (MiB)
+                 , fMem :: Int     -- ^ Free memory (MiB)
+                 , xMem :: Int     -- ^ Unaccounted memory (MiB)
+                 , tDsk :: Double  -- ^ Total disk space (MiB)
+                 , fDsk :: Int     -- ^ Free disk space (MiB)
+                 , tCpu :: Double  -- ^ Total CPU count
+                 , uCpu :: Int     -- ^ Used VCPU count
+                 , pList :: [T.Idx]-- ^ List of primary instance indices
+                 , sList :: [T.Idx]-- ^ List of secondary instance indices
                  , idx :: T.Ndx    -- ^ Internal index for book-keeping
                  , peers :: PeerMap.PeerMap -- ^ Pnode to instance mapping
                  , failN1:: Bool   -- ^ Whether the node has failed n1
-                 , r_mem :: Int    -- ^ Maximum memory needed for
+                 , rMem :: Int     -- ^ Maximum memory needed for
                                    -- failover by primaries of this node
-                 , p_mem :: Double -- ^ Percent of free memory
-                 , p_dsk :: Double -- ^ Percent of free disk
-                 , p_rem :: Double -- ^ Percent of reserved memory
-                 , p_cpu :: Double -- ^ Ratio of virtual to physical CPUs
-                 , m_dsk :: Double -- ^ Minimum free disk ratio
-                 , m_cpu :: Double -- ^ Max ratio of virt-to-phys CPUs
-                 , lo_dsk :: Int   -- ^ Autocomputed from m_dsk low disk
+                 , pMem :: Double  -- ^ Percent of free memory
+                 , pDsk :: Double  -- ^ Percent of free disk
+                 , pRem :: Double  -- ^ Percent of reserved memory
+                 , pCpu :: Double  -- ^ Ratio of virtual to physical CPUs
+                 , mDsk :: Double  -- ^ Minimum free disk ratio
+                 , mCpu :: Double  -- ^ Max ratio of virt-to-phys CPUs
+                 , loDsk :: Int    -- ^ Autocomputed from mDsk low disk
                                    -- threshold
-                 , hi_cpu :: Int   -- ^ Autocomputed from m_cpu high cpu
+                 , hiCpu :: Int    -- ^ Autocomputed from mCpu high cpu
                                    -- threshold
                  , offline :: Bool -- ^ Whether the node should not be used
                                    -- for allocations and skipped from
@@ -142,29 +142,29 @@ create name_init mem_t_init mem_n_init mem_f_init
     Node
     {
       name  = name_init,
-      t_mem = mem_t_init,
-      n_mem = mem_n_init,
-      f_mem = mem_f_init,
-      t_dsk = dsk_t_init,
-      f_dsk = dsk_f_init,
-      t_cpu = cpu_t_init,
-      u_cpu = 0,
-      plist = [],
-      slist = [],
+      tMem = mem_t_init,
+      nMem = mem_n_init,
+      fMem = mem_f_init,
+      tDsk = dsk_t_init,
+      fDsk = dsk_f_init,
+      tCpu = cpu_t_init,
+      uCpu = 0,
+      pList = [],
+      sList = [],
       failN1 = True,
       idx = -1,
       peers = PeerMap.empty,
-      r_mem = 0,
-      p_mem = fromIntegral mem_f_init / mem_t_init,
-      p_dsk = fromIntegral dsk_f_init / dsk_t_init,
-      p_rem = 0,
-      p_cpu = 0,
+      rMem = 0,
+      pMem = fromIntegral mem_f_init / mem_t_init,
+      pDsk = fromIntegral dsk_f_init / dsk_t_init,
+      pRem = 0,
+      pCpu = 0,
       offline = offline_init,
-      x_mem = 0,
-      m_dsk = noLimit,
-      m_cpu = noLimit,
-      lo_dsk = noLimitInt,
-      hi_cpu = noLimitInt
+      xMem = 0,
+      mDsk = noLimit,
+      mCpu = noLimit,
+      loDsk = noLimitInt,
+      hiCpu = noLimitInt
     }
 
 -- | Changes the index.
@@ -185,18 +185,18 @@ setOffline t val = t { offline = val }
 
 -- | Sets the unnaccounted memory.
 setXmem :: Node -> Int -> Node
-setXmem t val = t { x_mem = val }
+setXmem t val = t { xMem = val }
 
 -- | Sets the max disk usage ratio
 setMdsk :: Node -> Double -> Node
-setMdsk t val = t { m_dsk = val,
-                    lo_dsk = if val == noLimit
+setMdsk t val = t { mDsk = val,
+                    loDsk = if val == noLimit
                              then noLimitInt
-                             else floor (val * t_dsk t) }
+                             else floor (val * tDsk t) }
 
 -- | Sets the max cpu usage ratio
 setMcpu :: Node -> Double -> Node
-setMcpu t val = t { m_cpu = val, hi_cpu = floor (val * t_cpu t) }
+setMcpu t val = t { mCpu = val, hiCpu = floor (val * tCpu t) }
 
 -- | Computes the maximum reserved memory for peers from a peer map.
 computeMaxRes :: PeerMap.PeerMap -> PeerMap.Elem
@@ -207,98 +207,98 @@ buildPeers :: Node -> Instance.List -> Node
 buildPeers t il =
     let mdata = map
                 (\i_idx -> let inst = Container.find i_idx il
-                           in (Instance.pnode inst, Instance.mem inst))
-                (slist t)
+                           in (Instance.pNode inst, Instance.mem inst))
+                (sList t)
         pmap = PeerMap.accumArray (+) mdata
         new_rmem = computeMaxRes pmap
-        new_failN1 = f_mem t <= new_rmem
-        new_prem = fromIntegral new_rmem / t_mem t
-    in t {peers=pmap, failN1 = new_failN1, r_mem = new_rmem, p_rem = new_prem}
+        new_failN1 = fMem t <= new_rmem
+        new_prem = fromIntegral new_rmem / tMem t
+    in t {peers=pmap, failN1 = new_failN1, rMem = new_rmem, pRem = new_prem}
 
 -- | Assigns an instance to a node as primary without other updates.
 setPri :: Node -> T.Idx -> Node
-setPri t ix = t { plist = ix:plist t }
+setPri t ix = t { pList = ix:pList t }
 
 -- | Assigns an instance to a node as secondary without other updates.
 setSec :: Node -> T.Idx -> Node
-setSec t ix = t { slist = ix:slist t }
+setSec t ix = t { sList = ix:sList t }
 
 -- | Add primary cpus to a node
 addCpus :: Node -> Int -> Node
 addCpus t count =
-    let new_count = u_cpu t + count
-    in t { u_cpu = new_count, p_cpu = fromIntegral new_count / t_cpu t }
+    let new_count = uCpu t + count
+    in t { uCpu = new_count, pCpu = fromIntegral new_count / tCpu t }
 
 -- * Update functions
 
 -- | Sets the free memory.
 setFmem :: Node -> Int -> Node
 setFmem t new_mem =
-    let new_n1 = new_mem <= r_mem t
-        new_mp = fromIntegral new_mem / t_mem t
+    let new_n1 = new_mem <= rMem t
+        new_mp = fromIntegral new_mem / tMem t
     in
-      t { f_mem = new_mem, failN1 = new_n1, p_mem = new_mp }
+      t { fMem = new_mem, failN1 = new_n1, pMem = new_mp }
 
 -- | Removes a primary instance.
 removePri :: Node -> Instance.Instance -> Node
 removePri t inst =
     let iname = Instance.idx inst
-        new_plist = delete iname (plist t)
-        new_mem = f_mem t + Instance.mem inst
-        new_dsk = f_dsk t + Instance.dsk inst
-        new_mp = fromIntegral new_mem / t_mem t
-        new_dp = fromIntegral new_dsk / t_dsk t
-        new_failn1 = new_mem <= r_mem t
-        new_ucpu = u_cpu t - Instance.vcpus inst
-        new_rcpu = fromIntegral new_ucpu / t_cpu t
-    in t {plist = new_plist, f_mem = new_mem, f_dsk = new_dsk,
-          failN1 = new_failn1, p_mem = new_mp, p_dsk = new_dp,
-          u_cpu = new_ucpu, p_cpu = new_rcpu}
+        new_plist = delete iname (pList t)
+        new_mem = fMem t + Instance.mem inst
+        new_dsk = fDsk t + Instance.dsk inst
+        new_mp = fromIntegral new_mem / tMem t
+        new_dp = fromIntegral new_dsk / tDsk t
+        new_failn1 = new_mem <= rMem t
+        new_ucpu = uCpu t - Instance.vcpus inst
+        new_rcpu = fromIntegral new_ucpu / tCpu t
+    in t {pList = new_plist, fMem = new_mem, fDsk = new_dsk,
+          failN1 = new_failn1, pMem = new_mp, pDsk = new_dp,
+          uCpu = new_ucpu, pCpu = new_rcpu}
 
 -- | Removes a secondary instance.
 removeSec :: Node -> Instance.Instance -> Node
 removeSec t inst =
     let iname = Instance.idx inst
-        pnode = Instance.pnode inst
-        new_slist = delete iname (slist t)
-        new_dsk = f_dsk t + Instance.dsk inst
+        pnode = Instance.pNode inst
+        new_slist = delete iname (sList t)
+        new_dsk = fDsk t + Instance.dsk inst
         old_peers = peers t
         old_peem = PeerMap.find pnode old_peers
         new_peem =  old_peem - Instance.mem inst
         new_peers = PeerMap.add pnode new_peem old_peers
-        old_rmem = r_mem t
+        old_rmem = rMem t
         new_rmem = if old_peem < old_rmem then
                        old_rmem
                    else
                        computeMaxRes new_peers
-        new_prem = fromIntegral new_rmem / t_mem t
-        new_failn1 = f_mem t <= new_rmem
-        new_dp = fromIntegral new_dsk / t_dsk t
-    in t {slist = new_slist, f_dsk = new_dsk, peers = new_peers,
-          failN1 = new_failn1, r_mem = new_rmem, p_dsk = new_dp,
-          p_rem = new_prem}
+        new_prem = fromIntegral new_rmem / tMem t
+        new_failn1 = fMem t <= new_rmem
+        new_dp = fromIntegral new_dsk / tDsk t
+    in t {sList = new_slist, fDsk = new_dsk, peers = new_peers,
+          failN1 = new_failn1, rMem = new_rmem, pDsk = new_dp,
+          pRem = new_prem}
 
 -- | Adds a primary instance.
 addPri :: Node -> Instance.Instance -> T.OpResult Node
 addPri t inst =
     let iname = Instance.idx inst
-        new_mem = f_mem t - Instance.mem inst
-        new_dsk = f_dsk t - Instance.dsk inst
-        new_failn1 = new_mem <= r_mem t
-        new_ucpu = u_cpu t + Instance.vcpus inst
-        new_pcpu = fromIntegral new_ucpu / t_cpu t
-        new_dp = fromIntegral new_dsk / t_dsk t
-        l_cpu = m_cpu t
+        new_mem = fMem t - Instance.mem inst
+        new_dsk = fDsk t - Instance.dsk inst
+        new_failn1 = new_mem <= rMem t
+        new_ucpu = uCpu t + Instance.vcpus inst
+        new_pcpu = fromIntegral new_ucpu / tCpu t
+        new_dp = fromIntegral new_dsk / tDsk t
+        l_cpu = mCpu t
     in if new_mem <= 0 then T.OpFail T.FailMem
-       else if new_dsk <= 0 || m_dsk t > new_dp then T.OpFail T.FailDisk
+       else if new_dsk <= 0 || mDsk t > new_dp then T.OpFail T.FailDisk
        else if new_failn1 && not (failN1 t) then T.OpFail T.FailMem
        else if l_cpu >= 0 && l_cpu < new_pcpu then T.OpFail T.FailCPU
        else
-           let new_plist = iname:plist t
-               new_mp = fromIntegral new_mem / t_mem t
-               r = t { plist = new_plist, f_mem = new_mem, f_dsk = new_dsk,
-                       failN1 = new_failn1, p_mem = new_mp, p_dsk = new_dp,
-                       u_cpu = new_ucpu, p_cpu = new_pcpu }
+           let new_plist = iname:pList t
+               new_mp = fromIntegral new_mem / tMem t
+               r = t { pList = new_plist, fMem = new_mem, fDsk = new_dsk,
+                       failN1 = new_failn1, pMem = new_mp, pDsk = new_dp,
+                       uCpu = new_ucpu, pCpu = new_pcpu }
            in T.OpGood r
 
 -- | Adds a secondary instance.
@@ -306,21 +306,21 @@ addSec :: Node -> Instance.Instance -> T.Ndx -> T.OpResult Node
 addSec t inst pdx =
     let iname = Instance.idx inst
         old_peers = peers t
-        old_mem = f_mem t
-        new_dsk = f_dsk t - Instance.dsk inst
+        old_mem = fMem t
+        new_dsk = fDsk t - Instance.dsk inst
         new_peem = PeerMap.find pdx old_peers + Instance.mem inst
         new_peers = PeerMap.add pdx new_peem old_peers
-        new_rmem = max (r_mem t) new_peem
-        new_prem = fromIntegral new_rmem / t_mem t
+        new_rmem = max (rMem t) new_peem
+        new_prem = fromIntegral new_rmem / tMem t
         new_failn1 = old_mem <= new_rmem
-        new_dp = fromIntegral new_dsk / t_dsk t
-    in if new_dsk <= 0 || m_dsk t > new_dp then T.OpFail T.FailDisk
+        new_dp = fromIntegral new_dsk / tDsk t
+    in if new_dsk <= 0 || mDsk t > new_dp then T.OpFail T.FailDisk
        else if new_failn1 && not (failN1 t) then T.OpFail T.FailMem
-       else let new_slist = iname:slist t
-                r = t { slist = new_slist, f_dsk = new_dsk,
+       else let new_slist = iname:sList t
+                r = t { sList = new_slist, fDsk = new_dsk,
                         peers = new_peers, failN1 = new_failn1,
-                        r_mem = new_rmem, p_dsk = new_dp,
-                        p_rem = new_prem }
+                        rMem = new_rmem, pDsk = new_dp,
+                        pRem = new_prem }
            in T.OpGood r
 
 -- * Stats functions
@@ -328,8 +328,8 @@ addSec t inst pdx =
 -- | Computes the amount of available disk on a given node
 availDisk :: Node -> Int
 availDisk t =
-    let _f = f_dsk t
-        _l = lo_dsk t
+    let _f = fDsk t
+        _l = loDsk t
     in
       if _l == noLimitInt
       then _f
@@ -342,17 +342,17 @@ availDisk t =
 -- | String converter for the node list functionality.
 list :: Int -> Node -> String
 list mname t =
-    let pl = length $ plist t
-        sl = length $ slist t
-        mp = p_mem t
-        dp = p_dsk t
-        cp = p_cpu t
+    let pl = length $ pList t
+        sl = length $ sList t
+        mp = pMem t
+        dp = pDsk t
+        cp = pCpu t
         off = offline t
         fn = failN1 t
-        tmem = t_mem t
-        nmem = n_mem t
-        xmem = x_mem t
-        fmem = f_mem t
+        tmem = tMem t
+        nmem = nMem t
+        xmem = xMem t
+        fmem = fMem t
         imem = truncate tmem - nmem - xmem - fmem
     in
       if off
@@ -362,7 +362,7 @@ list mname t =
              printf " %c %-*s %5.0f %5d %5d %5d %5d %5d %5.0f %5d\
                     \ %4.0f %4d %3d %3d %6.4f %6.4f %5.2f"
                  (if off then '-' else if fn then '*' else ' ')
-                 mname (name t) tmem nmem imem xmem fmem (r_mem t)
-                 (t_dsk t / 1024) (f_dsk t `div` 1024)
-                 (t_cpu t) (u_cpu t)
+                 mname (name t) tmem nmem imem xmem fmem (rMem t)
+                 (tDsk t / 1024) (fDsk t `div` 1024)
+                 (tCpu t) (uCpu t)
                  pl sl mp dp cp
diff --git a/Ganeti/HTools/QC.hs b/Ganeti/HTools/QC.hs
index bb5b455e76cf28242f9eebf7660784301ab51224..c91c5b85f896d887e9cbe5a627f81fb9771839e4 100644
--- a/Ganeti/HTools/QC.hs
+++ b/Ganeti/HTools/QC.hs
@@ -154,27 +154,27 @@ prop_Instance_setName inst name =
     where _types = (inst::Instance.Instance, name::String)
 
 prop_Instance_setPri inst pdx =
-    Instance.pnode (Instance.setPri inst pdx) == pdx
+    Instance.pNode (Instance.setPri inst pdx) == pdx
     where _types = (inst::Instance.Instance, pdx::Types.Ndx)
 
 prop_Instance_setSec inst sdx =
-    Instance.snode (Instance.setSec inst sdx) == sdx
+    Instance.sNode (Instance.setSec inst sdx) == sdx
     where _types = (inst::Instance.Instance, sdx::Types.Ndx)
 
 prop_Instance_setBoth inst pdx sdx =
-    Instance.pnode si == pdx && Instance.snode si == sdx
+    Instance.pNode si == pdx && Instance.sNode si == sdx
     where _types = (inst::Instance.Instance, pdx::Types.Ndx, sdx::Types.Ndx)
           si = Instance.setBoth inst pdx sdx
 
 prop_Instance_runStatus_True inst =
     let run_st = Instance.running inst
-        run_tx = Instance.run_st inst
+        run_tx = Instance.runSt inst
     in
       run_tx == "running" || run_tx == "ERROR_up" ==> run_st == True
 
 prop_Instance_runStatus_False inst =
     let run_st = Instance.running inst
-        run_tx = Instance.run_st inst
+        run_tx = Instance.runSt inst
     in
       run_tx /= "running" && run_tx /= "ERROR_up" ==> run_st == False
 
@@ -213,8 +213,8 @@ prop_Text_Load_Instance name mem dsk vcpus status pnode snode pdx sdx =
             (Instance.name i == name &&
              Instance.vcpus i == vcpus &&
              Instance.mem i == mem &&
-             Instance.pnode i == pdx &&
-             Instance.snode i == rsdx)
+             Instance.pNode i == pdx &&
+             Instance.sNode i == rsdx)
 
 test_Text =
     [ run prop_Text_Load_Instance
@@ -223,8 +223,8 @@ test_Text =
 -- Node tests
 
 -- | Check that an instance add with too high memory or disk will be rejected
-prop_Node_addPri node inst = (Instance.mem inst >= Node.f_mem node ||
-                              Instance.dsk inst >= Node.f_dsk node) &&
+prop_Node_addPri node inst = (Instance.mem inst >= Node.fMem node ||
+                              Instance.dsk inst >= Node.fDsk node) &&
                              not (Node.failN1 node)
                              ==>
                              isFailure (Node.addPri node inst)
@@ -233,8 +233,8 @@ prop_Node_addPri node inst = (Instance.mem inst >= Node.f_mem node ||
 
 -- | Check that an instance add with too high memory or disk will be rejected
 prop_Node_addSec node inst pdx =
-    (Instance.mem inst >= (Node.f_mem node - Node.r_mem node) ||
-     Instance.dsk inst >= Node.f_dsk node) &&
+    (Instance.mem inst >= (Node.fMem node - Node.rMem node) ||
+     Instance.dsk inst >= Node.fDsk node) &&
     not (Node.failN1 node)
     ==> isFailure (Node.addSec node inst pdx)
         where _types = (node::Node.Node, inst::Instance.Instance, pdx::Int)
@@ -250,7 +250,7 @@ test_Node =
 -- | Check that the cluster score is close to zero for a homogeneous cluster
 prop_Score_Zero node count =
     ((not $ Node.offline node) && (not $ Node.failN1 node) && (count > 0) &&
-     (Node.t_dsk node > 0) && (Node.t_mem node > 0)) ==>
+     (Node.tDsk node > 0) && (Node.tMem node > 0)) ==>
     let fn = Node.buildPeers node Container.empty
         nlst = (zip [1..] $ replicate count fn)::[(Types.Ndx, Node.Node)]
         nl = Container.fromAssocList nlst
diff --git a/hscan.hs b/hscan.hs
index deac4e447faae84acc8fb48b0f6770ecff937f2a..21d27aaa0656ec029fb95520c4685a667dcf2e1e 100644
--- a/hscan.hs
+++ b/hscan.hs
@@ -60,8 +60,8 @@ options =
 serializeNode :: String -> Node.Node -> String
 serializeNode csf node =
     printf "%s|%.0f|%d|%d|%.0f|%d|%.0f|%c" (Node.name node ++ csf)
-               (Node.t_mem node) (Node.n_mem node) (Node.f_mem node)
-               (Node.t_dsk node) (Node.f_dsk node) (Node.t_cpu node)
+               (Node.tMem node) (Node.nMem node) (Node.fMem node)
+               (Node.tDsk node) (Node.fDsk node) (Node.tCpu node)
                (if Node.offline node then 'Y' else 'N')
 
 -- | Generate node file data from node objects
@@ -74,15 +74,15 @@ serializeInstance :: String -> Node.List -> Instance.Instance -> String
 serializeInstance csf nl inst =
     let
         iname = Instance.name inst ++ csf
-        pnode = Container.nameOf nl (Instance.pnode inst) ++ csf
-        sidx = Instance.snode inst
+        pnode = Container.nameOf nl (Instance.pNode inst) ++ csf
+        sidx = Instance.sNode inst
         snode = (if sidx == Node.noSecondary
                     then ""
                     else Container.nameOf nl sidx ++ csf)
     in
       printf "%s|%d|%d|%d|%s|%s|%s"
              iname (Instance.mem inst) (Instance.dsk inst)
-             (Instance.vcpus inst) (Instance.run_st inst)
+             (Instance.vcpus inst) (Instance.runSt inst)
              pnode snode
 
 -- | Generate instance file data from instance objects
@@ -98,10 +98,10 @@ printCluster nl il =
         ccv = Cluster.compCV nl
         nodes = Container.elems nl
         insts = Container.elems il
-        t_ram = sum . map Node.t_mem $ nodes
-        t_dsk = sum . map Node.t_dsk $ nodes
-        f_ram = sum . map Node.f_mem $ nodes
-        f_dsk = sum . map Node.f_dsk $ nodes
+        t_ram = sum . map Node.tMem $ nodes
+        t_dsk = sum . map Node.tDsk $ nodes
+        f_ram = sum . map Node.fMem $ nodes
+        f_dsk = sum . map Node.fDsk $ nodes
     in
       printf "%5d %5d %5d %5d %6.0f %6d %6.0f %6d %.8f"
                  (length nodes) (length insts)
diff --git a/hspace.hs b/hspace.hs
index d90aa151a1e99646a961b10642e25adfaf48a2a4..bc9c50e51fdf0e05f3ab28cea09b8badaa9038ea 100644
--- a/hspace.hs
+++ b/hspace.hs
@@ -257,8 +257,8 @@ main = do
          hPutStr stderr . unlines $
          map (\i -> printf "Inst: %*s %-*s %-*s"
                     ix_namelen (Instance.name i)
-                    nmlen (Container.nameOf fin_nl $ Instance.pnode i)
-                    nmlen (let sdx = Instance.snode i
+                    nmlen (Container.nameOf fin_nl $ Instance.pNode i)
+                    nmlen (let sdx = Instance.sNode i
                            in if sdx == Node.noSecondary then ""
                               else Container.nameOf fin_nl sdx)
              ) fin_ixes