Synnefo » snf-ganeti

{-# OPTIONS -fno-warn-type-defaults #-}

{-| HsConstants contains the Haskell constants

This is a transitional module complementary to 'Ganeti.Constants'.  It

is intended to contain the Haskell constants that are meant to be

generated in Python.

Do not write any definitions in this file other than constants.  Do

not even write helper functions.  The definitions in this module are

automatically stripped to build the Makefile.am target

'ListConstants.hs'.  If there are helper functions in this module,

they will also be dragged and it will cause compilation to fail.

Therefore, all helper functions should go to a separate module and

imported.

-}

{-

Copyright (C) 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.HsConstants where

import Control.Arrow ((***))

import Data.List ((\\))

import Data.Map (Map)

import qualified Data.Map as Map (empty, fromList, keys, insert)

import qualified AutoConf

import Ganeti.ConstantUtils (PythonChar(..), PythonNone(..), FrozenSet,

                             Protocol(..), buildVersion)

import qualified Ganeti.ConstantUtils as ConstantUtils

import Ganeti.HTools.Types (AutoRepairResult(..), AutoRepairType(..))

import qualified Ganeti.HTools.Types as Types

import Ganeti.Logging (SyslogUsage(..))

import qualified Ganeti.Logging as Logging (syslogUsageToRaw)

import qualified Ganeti.Runtime as Runtime

import Ganeti.Runtime (GanetiDaemon(..), MiscGroup(..), GanetiGroup(..),

                       ExtraLogReason(..))

import Ganeti.THH (PyValueEx(..))

import Ganeti.Types

import qualified Ganeti.Types as Types

import Ganeti.Confd.Types (ConfdRequestType(..), ConfdReqField(..),

                           ConfdReplyStatus(..), ConfdNodeRole(..),

                           ConfdErrorType(..))

import qualified Ganeti.Confd.Types as Types

{-# ANN module "HLint: ignore Use camelCase" #-}

-- * 'autoconf' constants for Python only ('autotools/build-bash-completion')

htoolsProgs :: [String]

htoolsProgs = AutoConf.htoolsProgs

-- * 'autoconf' constants for Python only ('lib/constants.py')

drbdBarriers :: String

drbdBarriers = AutoConf.drbdBarriers

drbdNoMetaFlush :: Bool

drbdNoMetaFlush = AutoConf.drbdNoMetaFlush

lvmStripecount :: Int

lvmStripecount = AutoConf.lvmStripecount

hasGnuLn :: Bool

hasGnuLn = AutoConf.hasGnuLn

-- * 'autoconf' constants for Python only ('lib/pathutils.py')

-- ** Build-time constants

exportDir :: String

exportDir = AutoConf.exportDir

osSearchPath :: [String]

osSearchPath = AutoConf.osSearchPath

esSearchPath :: [String]

esSearchPath = AutoConf.esSearchPath

sshConfigDir :: String

sshConfigDir = AutoConf.sshConfigDir

xenConfigDir :: String

xenConfigDir = AutoConf.xenConfigDir

sysconfdir :: String

sysconfdir = AutoConf.sysconfdir

toolsdir :: String

toolsdir = AutoConf.toolsdir

localstatedir :: String

localstatedir = AutoConf.localstatedir

-- ** Paths which don't change for a virtual cluster

pkglibdir :: String

pkglibdir = AutoConf.pkglibdir

sharedir :: String

sharedir = AutoConf.sharedir

-- * 'autoconf' constants for Python only ('lib/build/sphinx_ext.py')

manPages :: Map String Int

manPages = Map.fromList AutoConf.manPages

-- * 'autoconf' constants for QA cluster only ('qa/qa_cluster.py')

versionedsharedir :: String

versionedsharedir = AutoConf.versionedsharedir

-- * 'autoconf' constants for Python only ('tests/py/docs_unittest.py')

gntScripts :: [String]

gntScripts = AutoConf.gntScripts

-- * Various versions

releaseVersion :: String

releaseVersion = AutoConf.packageVersion

versionMajor :: Int

versionMajor = AutoConf.versionMajor

versionMinor :: Int

versionMinor = AutoConf.versionMinor

versionRevision :: Int

versionRevision = AutoConf.versionRevision

dirVersion :: String

dirVersion = AutoConf.dirVersion

osApiV10 :: Int

osApiV10 = 10

osApiV15 :: Int

osApiV15 = 15

osApiV20 :: Int

osApiV20 = 20

osApiVersions :: FrozenSet Int

osApiVersions = ConstantUtils.mkSet [osApiV10, osApiV15, osApiV20]

exportVersion :: Int

exportVersion = 0

rapiVersion :: Int

rapiVersion = 2

configMajor :: Int

configMajor = AutoConf.versionMajor

configMinor :: Int

configMinor = AutoConf.versionMinor

-- | The configuration is supposed to remain stable across

-- revisions. Therefore, the revision number is cleared to '0'.

configRevision :: Int

configRevision = 0

configVersion :: Int

configVersion = buildVersion configMajor configMinor configRevision

-- | Similarly to the configuration (see 'configRevision'), the

-- protocols are supposed to remain stable across revisions.

protocolVersion :: Int

protocolVersion = buildVersion configMajor configMinor configRevision

-- * User separation

daemonsGroup :: String

daemonsGroup = Runtime.daemonGroup (ExtraGroup DaemonsGroup)

adminGroup :: String

adminGroup = Runtime.daemonGroup (ExtraGroup AdminGroup)

masterdUser :: String

masterdUser = Runtime.daemonUser GanetiMasterd

masterdGroup :: String

masterdGroup = Runtime.daemonGroup (DaemonGroup GanetiMasterd)

rapiUser :: String

rapiUser = Runtime.daemonUser GanetiRapi

rapiGroup :: String

rapiGroup = Runtime.daemonGroup (DaemonGroup GanetiRapi)

confdUser :: String

confdUser = Runtime.daemonUser GanetiConfd

confdGroup :: String

confdGroup = Runtime.daemonGroup (DaemonGroup GanetiConfd)

luxidUser :: String

luxidUser = Runtime.daemonUser GanetiLuxid

luxidGroup :: String

luxidGroup = Runtime.daemonGroup (DaemonGroup GanetiLuxid)

nodedUser :: String

nodedUser = Runtime.daemonUser GanetiNoded

nodedGroup :: String

nodedGroup = Runtime.daemonGroup (DaemonGroup GanetiNoded)

mondUser :: String

mondUser = Runtime.daemonUser GanetiMond

mondGroup :: String

mondGroup = Runtime.daemonGroup (DaemonGroup GanetiMond)

sshLoginUser :: String

sshLoginUser = AutoConf.sshLoginUser

sshConsoleUser :: String

sshConsoleUser = AutoConf.sshConsoleUser

-- * Cpu pinning separators and constants

cpuPinningSep :: String

cpuPinningSep = ":"

cpuPinningAll :: String

cpuPinningAll = "all"

-- | Internal representation of "all"

cpuPinningAllVal :: Int

cpuPinningAllVal = -1

-- | One "all" entry in a CPU list means CPU pinning is off

cpuPinningOff :: [Int]

cpuPinningOff = [cpuPinningAllVal]

-- | A Xen-specific implementation detail is that there is no way to

-- actually say "use any cpu for pinning" in a Xen configuration file,

-- as opposed to the command line, where you can say

-- @

-- xm vcpu-pin <domain> <vcpu> all

-- @

--

-- The workaround used in Xen is "0-63" (see source code function

-- "xm_vcpu_pin" in @<xen-source>/tools/python/xen/xm/main.py@).

--

-- To support future changes, the following constant is treated as a

-- blackbox string that simply means "use any cpu for pinning under

-- xen".

cpuPinningAllXen :: String

cpuPinningAllXen = "0-63"

-- | A KVM-specific implementation detail - the following value is

-- used to set CPU affinity to all processors (--0 through --31), per

-- taskset man page.

--

-- FIXME: This only works for machines with up to 32 CPU cores

cpuPinningAllKvm :: Int

cpuPinningAllKvm = 0xFFFFFFFF

-- * Wipe

ddCmd :: String

ddCmd = "dd"

-- | 1GB

maxWipeChunk :: Int

maxWipeChunk = 1024

minWipeChunkPercent :: Int

minWipeChunkPercent = 10

-- * Directories

runDirsMode :: Int

runDirsMode = 0o775

secureDirMode :: Int

secureDirMode = 0o700

secureFileMode :: Int

secureFileMode = 0o600

adoptableBlockdevRoot :: String

adoptableBlockdevRoot = "/dev/disk/"

-- * 'autoconf' enable/disable

enableConfd :: Bool

enableConfd = AutoConf.enableConfd

enableMond :: Bool

enableMond = AutoConf.enableMond

enableRestrictedCommands :: Bool

enableRestrictedCommands = AutoConf.enableRestrictedCommands

enableSplitQuery :: Bool

enableSplitQuery = AutoConf.enableSplitQuery

-- * SSH constants

ssh :: String

ssh = "ssh"

scp :: String

scp = "scp"

-- * Daemons

confd :: String

confd = Runtime.daemonName GanetiConfd

masterd :: String

masterd = Runtime.daemonName GanetiMasterd

mond :: String

mond = Runtime.daemonName GanetiMond

noded :: String

noded = Runtime.daemonName GanetiNoded

luxid :: String

luxid = Runtime.daemonName GanetiLuxid

rapi :: String

rapi = Runtime.daemonName GanetiRapi

daemons :: FrozenSet String

daemons =

  ConstantUtils.mkSet [confd,

                       luxid,

                       masterd,

                       mond,

                       noded,

                       rapi]

defaultConfdPort :: Int

defaultConfdPort = 1814

defaultMondPort :: Int

defaultMondPort = 1815

defaultNodedPort :: Int

defaultNodedPort = 1811

defaultRapiPort :: Int

defaultRapiPort = 5080

daemonsPorts :: Map String (Protocol, Int)

daemonsPorts =

  Map.fromList [(confd, (Udp, defaultConfdPort)),

                (mond, (Tcp, defaultMondPort)),

                (noded, (Tcp, defaultNodedPort)),

                (rapi, (Tcp, defaultRapiPort)),

                (ssh, (Tcp, 22))]

firstDrbdPort :: Int

firstDrbdPort = 11000

lastDrbdPort :: Int

lastDrbdPort = 14999

daemonsLogbase :: Map String String

daemonsLogbase =

  Map.fromList

  [ (Runtime.daemonName d, Runtime.daemonLogBase d) | d <- [minBound..] ]

daemonsExtraLogbase :: Map String (Map String String)

daemonsExtraLogbase =

  Map.fromList $

  map (Runtime.daemonName *** id)

  [ (GanetiMond, Map.fromList

                 [ ("access", Runtime.daemonsExtraLogbase GanetiMond AccessLog)

                 , ("error", Runtime.daemonsExtraLogbase GanetiMond ErrorLog)

                 ])

  ]

extraLogreasonAccess :: String

extraLogreasonAccess = Runtime.daemonsExtraLogbase GanetiMond AccessLog

extraLogreasonError :: String

extraLogreasonError = Runtime.daemonsExtraLogbase GanetiMond ErrorLog

devConsole :: String

devConsole = ConstantUtils.devConsole

procMounts :: String

procMounts = "/proc/mounts"

-- * Luxi (Local UniX Interface) related constants

luxiEom :: PythonChar

luxiEom = PythonChar '\x03'

-- | Environment variable for the luxi override socket

luxiOverride :: String

luxiOverride = "FORCE_LUXI_SOCKET"

luxiOverrideMaster :: String

luxiOverrideMaster = "master"

luxiOverrideQuery :: String

luxiOverrideQuery = "query"

luxiVersion :: Int

luxiVersion = configVersion

-- * Syslog

syslogUsage :: String

syslogUsage = AutoConf.syslogUsage

syslogNo :: String

syslogNo = Logging.syslogUsageToRaw SyslogNo

syslogYes :: String

syslogYes = Logging.syslogUsageToRaw SyslogYes

syslogOnly :: String

syslogOnly = Logging.syslogUsageToRaw SyslogOnly

syslogSocket :: String

syslogSocket = "/dev/log"

exportConfFile :: String

exportConfFile = "config.ini"

-- * Xen

xenBootloader :: String

xenBootloader = AutoConf.xenBootloader

xenCmdXl :: String

xenCmdXl = "xl"

xenCmdXm :: String

xenCmdXm = "xm"

xenInitrd :: String

xenInitrd = AutoConf.xenInitrd

xenKernel :: String

xenKernel = AutoConf.xenKernel

-- FIXME: perhaps rename to 'validXenCommands' for consistency with

-- other constants

knownXenCommands :: FrozenSet String

knownXenCommands = ConstantUtils.mkSet [xenCmdXl, xenCmdXm]

-- * KVM and socat

kvmPath :: String

kvmPath = AutoConf.kvmPath

kvmKernel :: String

kvmKernel = AutoConf.kvmKernel

socatEscapeCode :: String

socatEscapeCode = "0x1d"

socatPath :: String

socatPath = AutoConf.socatPath

socatUseCompress :: Bool

socatUseCompress = AutoConf.socatUseCompress

socatUseEscape :: Bool

socatUseEscape = AutoConf.socatUseEscape

-- * Console types

-- | Display a message for console access

consMessage :: String

consMessage = "msg"

-- | Console as SPICE server

consSpice :: String

consSpice = "spice"

-- | Console as SSH command

consSsh :: String

consSsh = "ssh"

-- | Console as VNC server

consVnc :: String

consVnc = "vnc"

consAll :: FrozenSet String

consAll = ConstantUtils.mkSet [consMessage, consSpice, consSsh, consVnc]

-- | RSA key bit length

--

-- For RSA keys more bits are better, but they also make operations

-- more expensive. NIST SP 800-131 recommends a minimum of 2048 bits

-- from the year 2010 on.

rsaKeyBits :: Int

rsaKeyBits = 2048

-- | Ciphers allowed for SSL connections.

--

-- For the format, see ciphers(1). A better way to disable ciphers

-- would be to use the exclamation mark (!), but socat versions below

-- 1.5 can't parse exclamation marks in options properly. When

-- modifying the ciphers, ensure not to accidentially add something

-- after it's been removed. Use the "openssl" utility to check the

-- allowed ciphers, e.g.  "openssl ciphers -v HIGH:-DES".

opensslCiphers :: String

opensslCiphers = "HIGH:-DES:-3DES:-EXPORT:-ADH"

-- * X509

-- | commonName (CN) used in certificates

x509CertCn :: String

x509CertCn = "ganeti.example.com"

-- | Default validity of certificates in days

x509CertDefaultValidity :: Int

x509CertDefaultValidity = 365 * 5

x509CertSignatureHeader :: String

x509CertSignatureHeader = "X-Ganeti-Signature"

-- | Digest used to sign certificates ("openssl x509" uses SHA1 by default)

x509CertSignDigest :: String

x509CertSignDigest = "SHA1"

-- * Import/export daemon mode

iemExport :: String

iemExport = "export"

iemImport :: String

iemImport = "import"

-- * Import/export transport compression

iecGzip :: String

iecGzip = Types.importExportCompressionToRaw GZip

iecNone :: String

iecNone = Types.importExportCompressionToRaw None

iecAll :: FrozenSet String

iecAll =

  ConstantUtils.mkSet $ map Types.importExportCompressionToRaw [minBound..]

ieCustomSize :: String

ieCustomSize = "fd"

-- * Import/export I/O

-- | Direct file I/O, equivalent to a shell's I/O redirection using

-- '<' or '>'

ieioFile :: String

ieioFile = "file"

-- | Raw block device I/O using "dd"

ieioRawDisk :: String

ieioRawDisk = "raw"

-- | OS definition import/export script

ieioScript :: String

ieioScript = "script"

-- * Values

valueDefault :: String

valueDefault = "default"

valueAuto :: String

valueAuto = "auto"

valueGenerate :: String

valueGenerate = "generate"

valueNone :: String

valueNone = "none"

valueTrue :: String

valueTrue = "true"

valueFalse :: String

valueFalse = "false"

valueHsNothing :: Map String PythonNone

valueHsNothing = Map.fromList [("Nothing", PythonNone)]

-- * Hooks

hooksNameCfgupdate :: String

hooksNameCfgupdate = "config-update"

hooksNameWatcher :: String

hooksNameWatcher = "watcher"

hooksPath :: String

hooksPath = "/sbin:/bin:/usr/sbin:/usr/bin"

hooksPhasePost :: String

hooksPhasePost = "post"

hooksPhasePre :: String

hooksPhasePre = "pre"

hooksVersion :: Int

hooksVersion = 2

-- * Hooks subject type (what object type does the LU deal with)

htypeCluster :: String

htypeCluster = "CLUSTER"

htypeGroup :: String

htypeGroup = "GROUP"

htypeInstance :: String

htypeInstance = "INSTANCE"

htypeNetwork :: String

htypeNetwork = "NETWORK"

htypeNode :: String

htypeNode = "NODE"

-- * Hkr

hkrSkip :: Int

hkrSkip = 0

hkrFail :: Int

hkrFail = 1

hkrSuccess :: Int

hkrSuccess = 2

-- * Storage types

stBlock :: String

stBlock = Types.storageTypeToRaw StorageBlock

stDiskless :: String

stDiskless = Types.storageTypeToRaw StorageDiskless

stExt :: String

stExt = Types.storageTypeToRaw StorageExt

stFile :: String

stFile = Types.storageTypeToRaw StorageFile

stLvmPv :: String

stLvmPv = Types.storageTypeToRaw StorageLvmPv

stLvmVg :: String

stLvmVg = Types.storageTypeToRaw StorageLvmVg

stRados :: String

stRados = Types.storageTypeToRaw StorageRados

storageTypes :: FrozenSet String

storageTypes = ConstantUtils.mkSet $ map Types.storageTypeToRaw [minBound..]

-- | The set of storage types for which storage reporting is available

--

-- FIXME: Remove this, once storage reporting is available for all

-- types.

stsReport :: FrozenSet String

stsReport = ConstantUtils.mkSet [stFile, stLvmPv, stLvmVg]

-- * Storage fields

-- ** First two are valid in LU context only, not passed to backend

sfNode :: String

sfNode = "node"

sfType :: String

sfType = "type"

-- ** and the rest are valid in backend

sfAllocatable :: String

sfAllocatable = Types.storageFieldToRaw SFAllocatable

sfFree :: String

sfFree = Types.storageFieldToRaw SFFree

sfName :: String

sfName = Types.storageFieldToRaw SFName

sfSize :: String

sfSize = Types.storageFieldToRaw SFSize

sfUsed :: String

sfUsed = Types.storageFieldToRaw SFUsed

validStorageFields :: FrozenSet String

validStorageFields =

  ConstantUtils.mkSet $ map Types.storageFieldToRaw [minBound..] ++

                        [sfNode, sfType]

modifiableStorageFields :: Map String (FrozenSet String)

modifiableStorageFields =

  Map.fromList [(Types.storageTypeToRaw StorageLvmPv,

                 ConstantUtils.mkSet [sfAllocatable])]

-- * Storage operations

soFixConsistency :: String

soFixConsistency = "fix-consistency"

validStorageOperations :: Map String (FrozenSet String)

validStorageOperations =

  Map.fromList [(Types.storageTypeToRaw StorageLvmVg,

                 ConstantUtils.mkSet [soFixConsistency])]

-- * Volume fields

vfDev :: String

vfDev = "dev"

vfInstance :: String

vfInstance = "instance"

vfName :: String

vfName = "name"

vfNode :: String

vfNode = "node"

vfPhys :: String

vfPhys = "phys"

vfSize :: String

vfSize = "size"

vfVg :: String

vfVg = "vg"

-- * Local disk status

ldsFaulty :: Int

ldsFaulty = Types.localDiskStatusToRaw DiskStatusFaulty

ldsOkay :: Int

ldsOkay = Types.localDiskStatusToRaw DiskStatusOk

ldsUnknown :: Int

ldsUnknown = Types.localDiskStatusToRaw DiskStatusUnknown

ldsNames :: Map Int String

ldsNames =

  Map.fromList [ (Types.localDiskStatusToRaw ds,

                  localDiskStatusName ds) | ds <- [minBound..] ]

-- * Disk template types

dtDiskless :: String

dtDiskless = Types.diskTemplateToRaw DTDiskless

dtFile :: String

dtFile = Types.diskTemplateToRaw DTFile

dtSharedFile :: String

dtSharedFile = Types.diskTemplateToRaw DTSharedFile

dtPlain :: String

dtPlain = Types.diskTemplateToRaw DTPlain

dtBlock :: String

dtBlock = Types.diskTemplateToRaw DTBlock

dtDrbd8 :: String

dtDrbd8 = Types.diskTemplateToRaw DTDrbd8

dtRbd :: String

dtRbd = Types.diskTemplateToRaw DTRbd

dtExt :: String

dtExt = Types.diskTemplateToRaw DTExt

-- | This is used to order determine the default disk template when

-- the list of enabled disk templates is inferred from the current

-- state of the cluster.  This only happens on an upgrade from a

-- version of Ganeti that did not support the 'enabled_disk_templates'

-- so far.

diskTemplatePreference :: [String]

diskTemplatePreference =

  map Types.diskTemplateToRaw

  [DTBlock, DTDiskless, DTDrbd8, DTExt, DTFile, DTPlain, DTRbd, DTSharedFile]

diskTemplates :: FrozenSet String

diskTemplates = ConstantUtils.mkSet $ map Types.diskTemplateToRaw [minBound..]

-- | Disk templates that are enabled by default

defaultEnabledDiskTemplates :: [String]

defaultEnabledDiskTemplates = map Types.diskTemplateToRaw [DTDrbd8, DTPlain]

-- | Mapping of disk templates to storage types

mapDiskTemplateStorageType :: Map String String

mapDiskTemplateStorageType =

  Map.fromList $

  map (Types.diskTemplateToRaw *** Types.storageTypeToRaw)

  [(DTBlock, StorageBlock),

   (DTDrbd8, StorageLvmVg),

   (DTExt, StorageExt),

   (DTSharedFile, StorageFile),

   (DTFile, StorageFile),

   (DTDiskless, StorageDiskless),

   (DTPlain, StorageLvmVg),

   (DTRbd, StorageRados)]

-- | The set of network-mirrored disk templates

dtsIntMirror :: FrozenSet String

dtsIntMirror = ConstantUtils.mkSet [dtDrbd8]

-- | 'DTDiskless' is 'trivially' externally mirrored

dtsExtMirror :: FrozenSet String

dtsExtMirror =

  ConstantUtils.mkSet $

  map Types.diskTemplateToRaw [DTDiskless, DTBlock, DTExt, DTSharedFile, DTRbd]

-- | The set of non-lvm-based disk templates

dtsNotLvm :: FrozenSet String

dtsNotLvm =

  ConstantUtils.mkSet $

  map Types.diskTemplateToRaw

  [DTSharedFile, DTDiskless, DTBlock, DTExt, DTFile, DTRbd]

-- | The set of disk templates which can be grown

dtsGrowable :: FrozenSet String

dtsGrowable =

  ConstantUtils.mkSet $

  map Types.diskTemplateToRaw

  [DTSharedFile, DTDrbd8, DTPlain, DTExt, DTFile, DTRbd]

-- | The set of disk templates that allow adoption

dtsMayAdopt :: FrozenSet String

dtsMayAdopt =

  ConstantUtils.mkSet $ map Types.diskTemplateToRaw [DTBlock, DTPlain]

-- | The set of disk templates that *must* use adoption

dtsMustAdopt :: FrozenSet String

dtsMustAdopt = ConstantUtils.mkSet [Types.diskTemplateToRaw DTBlock]

-- | The set of disk templates that allow migrations

dtsMirrored :: FrozenSet String

dtsMirrored = dtsIntMirror `ConstantUtils.union` dtsExtMirror

-- | The set of file based disk templates

dtsFilebased :: FrozenSet String

dtsFilebased =

  ConstantUtils.mkSet $ map Types.diskTemplateToRaw [DTSharedFile, DTFile]

-- | The set of disk templates that can be moved by copying

--

-- Note: a requirement is that they're not accessed externally or

-- shared between nodes; in particular, sharedfile is not suitable.

dtsCopyable :: FrozenSet String

dtsCopyable =

  ConstantUtils.mkSet $ map Types.diskTemplateToRaw [DTPlain, DTFile]

-- | The set of disk templates that are supported by exclusive_storage

dtsExclStorage :: FrozenSet String

dtsExclStorage = ConstantUtils.mkSet $ map Types.diskTemplateToRaw [DTPlain]

-- | Templates for which we don't perform checks on free space

dtsNoFreeSpaceCheck :: FrozenSet String

dtsNoFreeSpaceCheck =

  ConstantUtils.mkSet $

  map Types.diskTemplateToRaw [DTExt, DTSharedFile, DTFile, DTRbd]

dtsBlock :: FrozenSet String

dtsBlock =

  ConstantUtils.mkSet $

  map Types.diskTemplateToRaw [DTPlain, DTDrbd8, DTBlock, DTRbd, DTExt]

-- | The set of lvm-based disk templates

dtsLvm :: FrozenSet String

dtsLvm = diskTemplates `ConstantUtils.difference` dtsNotLvm

-- * Drbd

drbdHmacAlg :: String

drbdHmacAlg = "md5"

drbdDefaultNetProtocol :: String

drbdDefaultNetProtocol = "C"

drbdMigrationNetProtocol :: String

drbdMigrationNetProtocol = "C"

drbdStatusFile :: String

drbdStatusFile = "/proc/drbd"

-- | Size of DRBD meta block device

drbdMetaSize :: Int

drbdMetaSize = 128

-- * Drbd barrier types

drbdBDiskBarriers :: String

drbdBDiskBarriers = "b"

drbdBDiskDrain :: String

drbdBDiskDrain = "d"

drbdBDiskFlush :: String

drbdBDiskFlush = "f"

drbdBNone :: String

drbdBNone = "n"

-- | Valid barrier combinations: "n" or any non-null subset of "bfd"

drbdValidBarrierOpt :: FrozenSet (FrozenSet String)

drbdValidBarrierOpt =

  ConstantUtils.mkSet

  [ ConstantUtils.mkSet [drbdBNone]

  , ConstantUtils.mkSet [drbdBDiskBarriers]

  , ConstantUtils.mkSet [drbdBDiskDrain]

  , ConstantUtils.mkSet [drbdBDiskFlush]

  , ConstantUtils.mkSet [drbdBDiskDrain, drbdBDiskFlush]

  , ConstantUtils.mkSet [drbdBDiskBarriers, drbdBDiskDrain]

  , ConstantUtils.mkSet [drbdBDiskBarriers, drbdBDiskFlush]

  , ConstantUtils.mkSet [drbdBDiskBarriers, drbdBDiskFlush, drbdBDiskDrain]

  ]

-- | Rbd tool command

rbdCmd :: String

rbdCmd = "rbd"

-- * File backend driver

fdBlktap :: String

fdBlktap = Types.fileDriverToRaw FileBlktap

fdLoop :: String

fdLoop = Types.fileDriverToRaw FileLoop

fileDriver :: FrozenSet String

fileDriver =

  ConstantUtils.mkSet $

  map Types.fileDriverToRaw [minBound..]

-- | The set of drbd-like disk types