Synnefo » snf-ganeti

{-| Module describing an instance.

The instance data type holds very few fields, the algorithm

intelligence is in the "Node" and "Cluster" modules.

-}

{-

Copyright (C) 2009, 2010, 2011, 2012, 2013 Google Inc.

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 2 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful, but

WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software

Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

02110-1301, USA.

-}

module Ganeti.HTools.Instance

  ( Instance(..)

  , Disk(..)

  , AssocList

  , List

  , create

  , isRunning

  , isOffline

  , notOffline

  , instanceDown

  , usesSecMem

  , applyIfOnline

  , setIdx

  , setName

  , setAlias

  , setPri

  , setSec

  , setBoth

  , setMovable

  , specOf

  , getTotalSpindles

  , instBelowISpec

  , instAboveISpec

  , instMatchesPolicy

  , shrinkByType

  , localStorageTemplates

  , hasSecondary

  , requiredNodes

  , allNodes

  , usesLocalStorage

  , mirrorType

  ) where

import Control.Monad (liftM2)

import Ganeti.BasicTypes

import qualified Ganeti.HTools.Types as T

import qualified Ganeti.HTools.Container as Container

import Ganeti.HTools.Nic (Nic)

import Ganeti.Utils

-- * Type declarations

data Disk = Disk

  { dskSize     :: Int       -- ^ Size in bytes

  , dskSpindles :: Maybe Int -- ^ Number of spindles

  } deriving (Show, Eq)

-- | The instance type.

data Instance = Instance

  { name         :: String    -- ^ The instance name

  , alias        :: String    -- ^ The shortened name

  , mem          :: Int       -- ^ Memory of the instance

  , dsk          :: Int       -- ^ Total disk usage of the instance

  , disks        :: [Disk]    -- ^ Sizes of the individual disks

  , vcpus        :: Int       -- ^ Number of VCPUs

  , runSt        :: T.InstanceStatus -- ^ Original run status

  , pNode        :: T.Ndx     -- ^ Original primary node

  , sNode        :: T.Ndx     -- ^ Original secondary node

  , idx          :: T.Idx     -- ^ Internal index

  , util         :: T.DynUtil -- ^ Dynamic resource usage

  , movable      :: Bool      -- ^ Can and should the instance be moved?

  , autoBalance  :: Bool      -- ^ Is the instance auto-balanced?

  , diskTemplate :: T.DiskTemplate -- ^ The disk template of the instance

  , spindleUse   :: Int       -- ^ The numbers of used spindles

  , allTags      :: [String]  -- ^ List of all instance tags

  , exclTags     :: [String]  -- ^ List of instance exclusion tags

  , arPolicy     :: T.AutoRepairPolicy -- ^ Instance's auto-repair policy

  , nics         :: [Nic]     -- ^ NICs of the instance

  } deriving (Show, Eq)

instance T.Element Instance where

  nameOf   = name

  idxOf    = idx

  setAlias = setAlias

  setIdx   = setIdx

  allNames n = [name n, alias n]

-- | Check if instance is running.

isRunning :: Instance -> Bool

isRunning (Instance {runSt = T.Running}) = True

isRunning (Instance {runSt = T.ErrorUp}) = True

isRunning _                              = False

-- | Check if instance is offline.

isOffline :: Instance -> Bool

isOffline (Instance {runSt = T.StatusOffline}) = True

isOffline _                                    = False

-- | Helper to check if the instance is not offline.

notOffline :: Instance -> Bool

notOffline = not . isOffline

-- | Check if instance is down.

instanceDown :: Instance -> Bool

instanceDown inst | isRunning inst = False

instanceDown inst | isOffline inst = False

instanceDown _                     = True

-- | Apply the function if the instance is online. Otherwise use

-- the initial value

applyIfOnline :: Instance -> (a -> a) -> a -> a

applyIfOnline = applyIf . notOffline

-- | Helper for determining whether an instance's memory needs to be

-- taken into account for secondary memory reservation.

usesSecMem :: Instance -> Bool

usesSecMem inst = notOffline inst && autoBalance inst

-- | Constant holding the local storage templates.

--

-- /Note:/ Currently Ganeti only exports node total/free disk space

-- for LVM-based storage; file-based storage is ignored in this model,

-- so even though file-based storage uses in reality disk space on the

-- node, in our model it won't affect it and we can't compute whether

-- there is enough disk space for a file-based instance. Therefore we

-- will treat this template as \'foreign\' storage.

localStorageTemplates :: [T.DiskTemplate]

localStorageTemplates = [ T.DTDrbd8, T.DTPlain ]

-- | Constant holding the movable disk templates.

--

-- This only determines the initial 'movable' state of the

-- instance. Further the movable state can be restricted more due to

-- user choices, etc.

movableDiskTemplates :: [T.DiskTemplate]

movableDiskTemplates =

  [ T.DTDrbd8

  , T.DTBlock

  , T.DTSharedFile

  , T.DTRbd

  , T.DTExt

  ]

-- | A simple name for the int, instance association list.

type AssocList = [(T.Idx, Instance)]

-- | A simple name for an instance map.

type List = Container.Container Instance

-- * Initialization

-- | Create an instance.

--

-- Some parameters are not initialized by function, and must be set

-- later (via 'setIdx' for example).

create :: String -> Int -> Int -> [Disk] -> Int -> T.InstanceStatus

       -> [String] -> Bool -> T.Ndx -> T.Ndx -> T.DiskTemplate -> Int

       -> [Nic] -> Instance

create name_init mem_init dsk_init disks_init vcpus_init run_init tags_init

       auto_balance_init pn sn dt su nics_init =

  Instance { name = name_init

           , alias = name_init

           , mem = mem_init

           , dsk = dsk_init

           , disks = disks_init

           , vcpus = vcpus_init

           , runSt = run_init

           , pNode = pn

           , sNode = sn

           , idx = -1

           , util = T.baseUtil

           , movable = supportsMoves dt

           , autoBalance = auto_balance_init

           , diskTemplate = dt

           , spindleUse = su

           , allTags = tags_init

           , exclTags = []

           , arPolicy = T.ArNotEnabled

           , nics = nics_init

           }

-- | Changes the index.

--

-- This is used only during the building of the data structures.

setIdx :: Instance -- ^ The original instance

       -> T.Idx    -- ^ New index

       -> Instance -- ^ The modified instance

setIdx t i = t { idx = i }

-- | Changes the name.

--

-- This is used only during the building of the data structures.

setName :: Instance -- ^ The original instance

        -> String   -- ^ New name

        -> Instance -- ^ The modified instance

setName t s = t { name = s, alias = s }

-- | Changes the alias.

--

-- This is used only during the building of the data structures.

setAlias :: Instance -- ^ The original instance

         -> String   -- ^ New alias

         -> Instance -- ^ The modified instance

setAlias t s = t { alias = s }

-- * Update functions

-- | Changes the primary node of the instance.

setPri :: Instance  -- ^ the original instance

        -> T.Ndx    -- ^ the new primary node

        -> Instance -- ^ the modified instance

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 }

-- | 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 }

-- | Sets the movable flag on an instance.

setMovable :: Instance -- ^ The original instance

           -> Bool     -- ^ New movable flag

           -> Instance -- ^ The modified instance

setMovable t m = t { movable = m }

-- | Try to shrink the instance based on the reason why we can't

-- allocate it.

shrinkByType :: Instance -> T.FailMode -> Result Instance

shrinkByType inst T.FailMem = let v = mem inst - T.unitMem

                              in if v < T.unitMem

                                 then Bad "out of memory"

                                 else Ok inst { mem = v }

shrinkByType inst T.FailDisk =

  let newdisks = [d {dskSize = dskSize d - T.unitDsk}| d <- disks inst]

      v = dsk inst - (length . disks $ inst) * T.unitDsk

  in if any (< T.unitDsk) $ map dskSize newdisks

     then Bad "out of disk"

     else Ok inst { dsk = v, disks = newdisks }

shrinkByType inst T.FailCPU = let v = vcpus inst - T.unitCpu

                              in if v < T.unitCpu

                                 then Bad "out of vcpus"

                                 else Ok inst { vcpus = v }

shrinkByType inst T.FailSpindles =

  case disks inst of

    [Disk ds sp] -> case sp of

                      Nothing -> Bad "No spindles, shouldn't have happened"

                      Just sp' -> let v = sp' - T.unitSpindle

                                  in if v < T.unitSpindle

                                     then Bad "out of spindles"

                                     else Ok inst { disks = [Disk ds (Just v)] }

    d -> Bad $ "Expected one disk, but found " ++ show d

shrinkByType _ f = Bad $ "Unhandled failure mode " ++ show f

-- | Get the number of disk spindles

getTotalSpindles :: Instance -> Maybe Int

getTotalSpindles inst =

  foldr (liftM2 (+) . dskSpindles ) (Just 0) (disks inst)

-- | Return the spec of an instance.

specOf :: Instance -> T.RSpec

specOf Instance { mem = m, dsk = d, vcpus = c, disks = dl } =

  let sp = case dl of

             [Disk _ (Just sp')] -> sp'

             _ -> 0

  in T.RSpec { T.rspecCpu = c, T.rspecMem = m,

               T.rspecDsk = d, T.rspecSpn = sp }

-- | Checks if an instance is smaller/bigger than a given spec. Returns

-- OpGood for a correct spec, otherwise Bad one of the possible

-- failure modes.

instCompareISpec :: Ordering -> Instance-> T.ISpec -> Bool -> T.OpResult ()

instCompareISpec which inst ispec exclstor

  | which == mem inst `compare` T.iSpecMemorySize ispec = Bad T.FailMem

  | which `elem` map ((`compare` T.iSpecDiskSize ispec) . dskSize)

    (disks inst) = Bad T.FailDisk

  | which == vcpus inst `compare` T.iSpecCpuCount ispec = Bad T.FailCPU

  | exclstor &&

    case getTotalSpindles inst of

      Nothing -> True

      Just sp_sum -> which == sp_sum `compare` T.iSpecSpindleUse ispec

    = Bad T.FailSpindles

  | not exclstor && which == spindleUse inst `compare` T.iSpecSpindleUse ispec

    = Bad T.FailSpindles

  | diskTemplate inst /= T.DTDiskless &&

    which == length (disks inst) `compare` T.iSpecDiskCount ispec

    = Bad T.FailDiskCount

  | otherwise = Ok ()

-- | Checks if an instance is smaller than a given spec.

instBelowISpec :: Instance -> T.ISpec -> Bool -> T.OpResult ()

instBelowISpec = instCompareISpec GT

-- | Checks if an instance is bigger than a given spec.

instAboveISpec :: Instance -> T.ISpec -> Bool -> T.OpResult ()

instAboveISpec = instCompareISpec LT

-- | Checks if an instance matches a min/max specs pair

instMatchesMinMaxSpecs :: Instance -> T.MinMaxISpecs -> Bool -> T.OpResult ()

instMatchesMinMaxSpecs inst minmax exclstor = do

  instAboveISpec inst (T.minMaxISpecsMinSpec minmax) exclstor

  instBelowISpec inst (T.minMaxISpecsMaxSpec minmax) exclstor

-- | Checks if an instance matches any specs of a policy

instMatchesSpecs :: Instance -> [T.MinMaxISpecs] -> Bool -> T.OpResult ()

 -- Return Ok for no constraints, though this should never happen

instMatchesSpecs _ [] _ = Ok ()

instMatchesSpecs inst minmaxes exclstor =

  -- The initial "Bad" should be always replaced by a real result

  foldr eithermatch (Bad T.FailInternal) minmaxes

  where eithermatch mm (Bad _) = instMatchesMinMaxSpecs inst mm exclstor

        eithermatch _ y@(Ok ()) = y

-- | Checks if an instance matches a policy.

instMatchesPolicy :: Instance -> T.IPolicy -> Bool -> T.OpResult ()

instMatchesPolicy inst ipol exclstor = do

  instMatchesSpecs inst (T.iPolicyMinMaxISpecs ipol) exclstor

  if diskTemplate inst `elem` T.iPolicyDiskTemplates ipol

    then Ok ()

    else Bad T.FailDisk

-- | Checks whether the instance uses a secondary node.

--

-- /Note:/ This should be reconciled with @'sNode' ==

-- 'Node.noSecondary'@.

hasSecondary :: Instance -> Bool

hasSecondary = (== T.DTDrbd8) . diskTemplate

-- | Computed the number of nodes for a given disk template.

requiredNodes :: T.DiskTemplate -> Int

requiredNodes T.DTDrbd8 = 2

requiredNodes _         = 1

-- | Computes all nodes of an instance.

allNodes :: Instance -> [T.Ndx]

allNodes inst = case diskTemplate inst of

                  T.DTDrbd8 -> [pNode inst, sNode inst]

                  _ -> [pNode inst]

-- | Checks whether a given disk template uses local storage.

usesLocalStorage :: Instance -> Bool

usesLocalStorage = (`elem` localStorageTemplates) . diskTemplate

-- | Checks whether a given disk template supported moves.

supportsMoves :: T.DiskTemplate -> Bool

supportsMoves = (`elem` movableDiskTemplates)

-- | A simple wrapper over 'T.templateMirrorType'.

mirrorType :: Instance -> T.MirrorType

mirrorType = T.templateMirrorType . diskTemplate