Synnefo » snf-ganeti

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

{-| Constants contains the Haskell constants

The constants in this module are used in Haskell and are also

converted to 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.

All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are

met:

1. Redistributions of source code must retain the above copyright notice,

this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright

notice, this list of conditions and the following disclaimer in the

documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS

IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED

TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR

CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

-}

module Ganeti.Constants 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(..), 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

backupDir :: String

backupDir = AutoConf.backupDir

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 = "gzip"

iecNone :: String

iecNone = "none"

iecAll :: [String]

iecAll = [iecGzip, iecNone]

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"

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

fdBlktap2 :: String

fdBlktap2 = Types.fileDriverToRaw FileBlktap2

fdLoop :: String

fdLoop = Types.fileDriverToRaw FileLoop

fdDefault :: String

fdDefault = fdLoop

fileDriver :: FrozenSet String

fileDriver =

  ConstantUtils.mkSet $

  map Types.fileDriverToRaw [minBound..]

-- | The set of drbd-like disk types

dtsDrbd :: FrozenSet String

dtsDrbd = ConstantUtils.mkSet [Types.diskTemplateToRaw DTDrbd8]

-- * Disk access mode

diskRdonly :: String

diskRdonly = Types.diskModeToRaw DiskRdOnly

diskRdwr :: String

diskRdwr = Types.diskModeToRaw DiskRdWr

diskAccessSet :: FrozenSet String

diskAccessSet = ConstantUtils.mkSet $ map Types.diskModeToRaw [minBound..]

-- * Disk replacement mode

replaceDiskAuto :: String

replaceDiskAuto = Types.replaceDisksModeToRaw ReplaceAuto

replaceDiskChg :: String

replaceDiskChg = Types.replaceDisksModeToRaw ReplaceNewSecondary

replaceDiskPri :: String

replaceDiskPri = Types.replaceDisksModeToRaw ReplaceOnPrimary

replaceDiskSec :: String

replaceDiskSec = Types.replaceDisksModeToRaw ReplaceOnSecondary

replaceModes :: FrozenSet String

replaceModes =

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

-- * Instance export mode

exportModeLocal :: String

exportModeLocal = Types.exportModeToRaw ExportModeLocal

exportModeRemote :: String

exportModeRemote = Types.exportModeToRaw ExportModeRemote

exportModes :: FrozenSet String

exportModes = ConstantUtils.mkSet $ map Types.exportModeToRaw [minBound..]

-- * Instance creation modes

instanceCreate :: String

instanceCreate = Types.instCreateModeToRaw InstCreate

instanceImport :: String

instanceImport = Types.instCreateModeToRaw InstImport

instanceRemoteImport :: String

instanceRemoteImport = Types.instCreateModeToRaw InstRemoteImport

instanceCreateModes :: FrozenSet String

instanceCreateModes =

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

-- * Remote import/export handshake message and version

rieHandshake :: String

rieHandshake = "Hi, I'm Ganeti"

rieVersion :: Int

rieVersion = 0

-- | Remote import/export certificate validity (seconds)

rieCertValidity :: Int

rieCertValidity = 24 * 60 * 60

-- | Export only: how long to wait per connection attempt (seconds)

rieConnectAttemptTimeout :: Int

rieConnectAttemptTimeout = 20

-- | Export only: number of attempts to connect

rieConnectRetries :: Int

rieConnectRetries = 10

-- | Overall timeout for establishing connection

rieConnectTimeout :: Int

rieConnectTimeout = 180

-- | Give child process up to 5 seconds to exit after sending a signal

childLingerTimeout :: Double

childLingerTimeout = 5.0

-- * Import/export config options

inisectBep :: String

inisectBep = "backend"

inisectExp :: String

inisectExp = "export"

inisectHyp :: String

inisectHyp = "hypervisor"

inisectIns :: String

inisectIns = "instance"

inisectOsp :: String

inisectOsp = "os"

-- * Dynamic device modification

ddmAdd :: String

ddmAdd = Types.ddmFullToRaw DdmFullAdd

ddmModify :: String

ddmModify = Types.ddmFullToRaw DdmFullModify

ddmRemove :: String

ddmRemove = Types.ddmFullToRaw DdmFullRemove

ddmsValues :: FrozenSet String

ddmsValues = ConstantUtils.mkSet [ddmAdd, ddmRemove]

ddmsValuesWithModify :: FrozenSet String

ddmsValuesWithModify = ConstantUtils.mkSet $ map Types.ddmFullToRaw [minBound..]

-- * Common exit codes

exitSuccess :: Int

exitSuccess = 0

exitFailure :: Int

exitFailure = ConstantUtils.exitFailure

exitNotcluster :: Int

exitNotcluster = 5

exitNotmaster :: Int

exitNotmaster = 11

exitNodesetupError :: Int

exitNodesetupError = 12

-- | Need user confirmation

exitConfirmation :: Int

exitConfirmation = 13

-- | Exit code for query operations with unknown fields

exitUnknownField :: Int

exitUnknownField = 14

-- * Tags

tagCluster :: String

tagCluster = Types.tagKindToRaw TagKindCluster

tagInstance :: String

tagInstance = Types.tagKindToRaw TagKindInstance

tagNetwork :: String

tagNetwork = Types.tagKindToRaw TagKindNetwork

tagNode :: String

tagNode = Types.tagKindToRaw TagKindNode

tagNodegroup :: String

tagNodegroup = Types.tagKindToRaw TagKindGroup

validTagTypes :: FrozenSet String

validTagTypes = ConstantUtils.mkSet $ map Types.tagKindToRaw [minBound..]

maxTagLen :: Int

maxTagLen = 128

maxTagsPerObj :: Int

maxTagsPerObj = 4096

-- * Others

defaultBridge :: String

defaultBridge = "xen-br0"

defaultOvs :: String

defaultOvs = "switch1"

-- | 60 MiB/s, expressed in KiB/s

classicDrbdSyncSpeed :: Int

classicDrbdSyncSpeed = 60 * 1024

ip4AddressAny :: String

ip4AddressAny = "0.0.0.0"

ip4AddressLocalhost :: String

ip4AddressLocalhost = "127.0.0.1"

ip6AddressAny :: String

ip6AddressAny = "::"

ip6AddressLocalhost :: String

ip6AddressLocalhost = "::1"

ip4Version :: Int

ip4Version = 4

ip6Version :: Int

ip6Version = 6

validIpVersions :: FrozenSet Int

validIpVersions = ConstantUtils.mkSet [ip4Version, ip6Version]

tcpPingTimeout :: Int

tcpPingTimeout = 10

defaultVg :: String

defaultVg = "xenvg"

defaultDrbdHelper :: String

defaultDrbdHelper = "/bin/true"

minVgSize :: Int

minVgSize = 20480

defaultMacPrefix :: String

defaultMacPrefix = "aa:00:00"

-- | Default maximum instance wait time (seconds)

defaultShutdownTimeout :: Int

defaultShutdownTimeout = 120

-- | Node clock skew (seconds)

nodeMaxClockSkew :: Int

nodeMaxClockSkew = 150

-- | Time for an intra-cluster disk transfer to wait for a connection

diskTransferConnectTimeout :: Int

diskTransferConnectTimeout = 60

-- | Disk index separator

diskSeparator :: String

diskSeparator = AutoConf.diskSeparator

ipCommandPath :: String

ipCommandPath = AutoConf.ipPath

-- | Key for job IDs in opcode result

jobIdsKey :: String

jobIdsKey = "jobs"

-- * Runparts results

runpartsErr :: Int

runpartsErr = 2

runpartsRun :: Int

runpartsRun = 1

runpartsSkip :: Int

runpartsSkip = 0

runpartsStatus :: [Int]

runpartsStatus = [runpartsErr, runpartsRun, runpartsSkip]

-- * RPC

rpcEncodingNone :: Int

rpcEncodingNone = 0

rpcEncodingZlibBase64 :: Int

rpcEncodingZlibBase64 = 1

-- * Timeout table

--

-- Various time constants for the timeout table

rpcTmoUrgent :: Int

rpcTmoUrgent = Types.rpcTimeoutToRaw Urgent

rpcTmoFast :: Int

rpcTmoFast = Types.rpcTimeoutToRaw Fast

rpcTmoNormal :: Int

rpcTmoNormal = Types.rpcTimeoutToRaw Normal

rpcTmoSlow :: Int

rpcTmoSlow = Types.rpcTimeoutToRaw Slow

-- | 'rpcTmo_4hrs' contains an underscore to circumvent a limitation

-- in the 'Ganeti.THH.deCamelCase' function and generate the correct

-- Python name.

rpcTmo_4hrs :: Int

rpcTmo_4hrs = Types.rpcTimeoutToRaw FourHours

-- | 'rpcTmo_1day' contains an underscore to circumvent a limitation

-- in the 'Ganeti.THH.deCamelCase' function and generate the correct

-- Python name.

rpcTmo_1day :: Int

rpcTmo_1day = Types.rpcTimeoutToRaw OneDay

-- | Timeout for connecting to nodes (seconds)

rpcConnectTimeout :: Int

rpcConnectTimeout = 5

-- OS

osScriptCreate :: String

osScriptCreate = "create"

osScriptExport :: String

osScriptExport = "export"

osScriptImport :: String

osScriptImport = "import"

osScriptRename :: String

osScriptRename = "rename"

osScriptVerify :: String

osScriptVerify = "verify"

osScripts :: [String]

osScripts = [osScriptCreate, osScriptExport, osScriptImport, osScriptRename,

             osScriptVerify]

osApiFile :: String

osApiFile = "ganeti_api_version"

osVariantsFile :: String

osVariantsFile = "variants.list"

osParametersFile :: String

osParametersFile = "parameters.list"

osValidateParameters :: String

osValidateParameters = "parameters"

osValidateCalls :: FrozenSet String

osValidateCalls = ConstantUtils.mkSet [osValidateParameters]

-- | External Storage (ES) related constants

esActionAttach :: String

esActionAttach = "attach"

esActionCreate :: String

esActionCreate = "create"

esActionDetach :: String

esActionDetach = "detach"

esActionGrow :: String

esActionGrow = "grow"

esActionRemove :: String

esActionRemove = "remove"

esActionSetinfo :: String

esActionSetinfo = "setinfo"

esActionVerify :: String

esActionVerify = "verify"

esScriptCreate :: String

esScriptCreate = esActionCreate

esScriptRemove :: String

esScriptRemove = esActionRemove

esScriptGrow :: String

esScriptGrow = esActionGrow

esScriptAttach :: String

esScriptAttach = esActionAttach

esScriptDetach :: String

esScriptDetach = esActionDetach

esScriptSetinfo :: String

esScriptSetinfo = esActionSetinfo

esScriptVerify :: String

esScriptVerify = esActionVerify

esScripts :: FrozenSet String

esScripts =

  ConstantUtils.mkSet [esScriptAttach,

                       esScriptCreate,

                       esScriptDetach,

                       esScriptGrow,

                       esScriptRemove,

                       esScriptSetinfo,

                       esScriptVerify]

esParametersFile :: String

esParametersFile = "parameters.list"

-- * Reboot types

instanceRebootSoft :: String

instanceRebootSoft = Types.rebootTypeToRaw RebootSoft

instanceRebootHard :: String

instanceRebootHard = Types.rebootTypeToRaw RebootHard

instanceRebootFull :: String

instanceRebootFull = Types.rebootTypeToRaw RebootFull

rebootTypes :: FrozenSet String

rebootTypes = ConstantUtils.mkSet $ map Types.rebootTypeToRaw [minBound..]

-- * Instance reboot behaviors

instanceRebootAllowed :: String

instanceRebootAllowed = "reboot"

instanceRebootExit :: String

instanceRebootExit = "exit"

rebootBehaviors :: [String]

rebootBehaviors = [instanceRebootAllowed, instanceRebootExit]

-- * VTypes

vtypeBool :: VType

vtypeBool = VTypeBool

vtypeInt :: VType

vtypeInt = VTypeInt

vtypeMaybeString :: VType

vtypeMaybeString = VTypeMaybeString

-- | Size in MiBs

vtypeSize :: VType

vtypeSize = VTypeSize

vtypeString :: VType

vtypeString = VTypeString

enforceableTypes :: FrozenSet VType

enforceableTypes = ConstantUtils.mkSet [minBound..]

-- | Constant representing that the user does not specify any IP version

ifaceNoIpVersionSpecified :: Int

ifaceNoIpVersionSpecified = 0

validSerialSpeeds :: [Int]

validSerialSpeeds =

  [75,

   110,

   300,

   600,

   1200,

   1800,

   2400,

   4800,

   9600,

   14400,

   19200,

   28800,

   38400,

   57600,

   115200,

   230400,

   345600,

   460800]

-- * HV parameter names (global namespace)

hvAcpi :: String

hvAcpi = "acpi"

hvBlockdevPrefix :: String

hvBlockdevPrefix = "blockdev_prefix"

hvBootloaderArgs :: String

hvBootloaderArgs = "bootloader_args"

hvBootloaderPath :: String

hvBootloaderPath = "bootloader_path"

hvBootOrder :: String

hvBootOrder = "boot_order"

hvCdromImagePath :: String

hvCdromImagePath = "cdrom_image_path"

hvCpuCap :: String

hvCpuCap = "cpu_cap"

hvCpuCores :: String

hvCpuCores = "cpu_cores"

hvCpuMask :: String

hvCpuMask = "cpu_mask"

hvCpuSockets :: String

hvCpuSockets = "cpu_sockets"

hvCpuThreads :: String

hvCpuThreads = "cpu_threads"

hvCpuType :: String

hvCpuType = "cpu_type"

hvCpuWeight :: String

hvCpuWeight = "cpu_weight"

hvDeviceModel :: String

hvDeviceModel = "device_model"

hvDiskCache :: String

hvDiskCache = "disk_cache"

hvDiskType :: String

hvDiskType = "disk_type"

hvInitrdPath :: String

hvInitrdPath = "initrd_path"

hvInitScript :: String

hvInitScript = "init_script"

hvKernelArgs :: String

hvKernelArgs = "kernel_args"

hvKernelPath :: String

hvKernelPath = "kernel_path"

hvKeymap :: String

hvKeymap = "keymap"

hvKvmCdrom2ImagePath :: String

hvKvmCdrom2ImagePath = "cdrom2_image_path"

hvKvmCdromDiskType :: String

hvKvmCdromDiskType = "cdrom_disk_type"

hvKvmExtra :: String

hvKvmExtra = "kvm_extra"

hvKvmFlag :: String

hvKvmFlag = "kvm_flag"

hvKvmFloppyImagePath :: String

hvKvmFloppyImagePath = "floppy_image_path"

hvKvmMachineVersion :: String

hvKvmMachineVersion = "machine_version"

hvKvmPath :: String

hvKvmPath = "kvm_path"

hvKvmSpiceAudioCompr :: String

hvKvmSpiceAudioCompr = "spice_playback_compression"

hvKvmSpiceBind :: String

hvKvmSpiceBind = "spice_bind"

hvKvmSpiceIpVersion :: String

hvKvmSpiceIpVersion = "spice_ip_version"

hvKvmSpiceJpegImgCompr :: String

hvKvmSpiceJpegImgCompr = "spice_jpeg_wan_compression"

hvKvmSpiceLosslessImgCompr :: String

hvKvmSpiceLosslessImgCompr = "spice_image_compression"

hvKvmSpicePasswordFile :: String

hvKvmSpicePasswordFile = "spice_password_file"

hvKvmSpiceStreamingVideoDetection :: String