Safe HaskellNone




TemplateHaskell helper for Ganeti Haskell code.

As TemplateHaskell require that splices be defined in a separate module, we combine all the TemplateHaskell functionality that HTools needs in this module (except the one for unittests).


Exported types

class DictObject a whereSource

Class of objects that can be converted to JSObject lists-format.


toDict :: a -> [(String, JSValue)]Source

data Field Source

Serialised field data type.




fieldName :: String
fieldType :: Q Type
fieldRead :: Maybe (Q Exp)
fieldShow :: Maybe (Q Exp)
fieldExtraKeys :: [String]
fieldDefault :: Maybe (Q Exp)
fieldConstr :: Maybe String
fieldIsOptional :: OptionalType
fieldDoc :: String

simpleField :: String -> Q Type -> FieldSource

Generates a simple field.

withDoc :: String -> Field -> FieldSource

renameField :: String -> Field -> FieldSource

Sets the renamed constructor field.

defaultField :: Q Exp -> Field -> FieldSource

Sets the default value on a field (makes it optional with a default value).

optionalField :: Field -> FieldSource

Marks a field optional (turning its base type into a Maybe).

optionalNullSerField :: Field -> FieldSource

Marks a field optional (turning its base type into a Maybe), but with Nothing serialised explicitly as null.



:: Name

The name of the read function

-> Name

The name of the show function

-> [String]

The name of extra field keys

-> Field

The original field

-> Field

Updated field

Sets custom functions on a field.

checkNonOptDef :: Monad m => Field -> m ()Source

loadFn :: Field -> Q Exp -> Q Exp -> Q ExpSource

Common field declarations

timeStampFields :: [Field]Source

Timestamp fields description.

serialFields :: [Field]Source

Serial number fields description.

uuidFields :: [Field]Source

UUID fields description.

type TagSet = Set StringSource

Tag set type alias.

tagsFields :: [Field]Source

Tag field description.

Internal types

type SimpleField = (String, Q Type)Source

type OpCodeConstructor = (String, Q Type, String, [Field], String)Source

type LuxiConstructor = (String, [Field])Source

Helper functions

ensureLower :: String -> StringSource

ensureUpper :: String -> StringSource

varNameE :: String -> Q ExpSource

toRawName :: String -> NameSource

fromRawName :: String -> NameSource

reprE :: Either String Name -> Q ExpSource

appFn :: Exp -> Exp -> ExpSource

buildConsField :: Q Type -> StrictTypeQSource

genSaveSimpleObj :: Name -> String -> SimpleObject -> (SimpleConstructor -> Q Clause) -> Q (Dec, Dec)Source

Template code for simple raw type-equivalent ADTs

strADTDecl :: Name -> [String] -> DecSource

genToRaw :: Name -> Name -> Name -> [(String, Either String Name)] -> Q [Dec]Source

genFromRaw :: Name -> Name -> Name -> [(String, Either String Name)] -> Q [Dec]Source

declareADT :: (a -> Either String Name) -> Name -> String -> [(String, a)] -> Q [Dec]Source

declareLADT :: Name -> String -> [(String, String)] -> Q [Dec]Source

declareILADT :: String -> [(String, Int)] -> Q [Dec]Source

declareIADT :: String -> [(String, Name)] -> Q [Dec]Source

declareSADT :: String -> [(String, Name)] -> Q [Dec]Source

genShowJSON :: String -> Q DecSource

genReadJSON :: String -> Q DecSource

makeJSONInstance :: Name -> Q [Dec]Source

Generates a JSON instance for a given type.

This assumes that the nameToRaw and nameFromRaw functions have been defined as by the declareSADT function.

Template code for opcodes

deCamelCase :: String -> StringSource

Transforms a CamelCase string into an_underscore_based_one.

camelCase :: String -> StringSource

constructorName :: Con -> Q NameSource

reifyConsNames :: Name -> Q [String]Source

genConstrToStr :: (String -> String) -> Name -> String -> Q [Dec]Source

genOpID :: Name -> String -> Q [Dec]Source

Constructor-to-string for OpCode.

genAllConstr :: (String -> String) -> Name -> String -> Q [Dec]Source

Builds a list with all defined constructor names for a type.

 vstr :: String
 vstr = [...]

Where the actual values of the string are the constructor names mapped via trans_fun.

genAllOpIDs :: Name -> String -> Q [Dec]Source

Generates a list of all defined opcode IDs.

type OpParam = (String, Q Type, Q Exp)Source

Python code generation

class PyValue a whereSource

Converts Haskell values into Python values

This is necessary for the default values of opcode parameters and return values. For example, if a default value or return type is a Data.Map, then it must be shown as a Python dictioanry.


showValue :: a -> StringSource


PyValue Bool 
PyValue Char 
PyValue Double 
PyValue Int 
PyValue Integer 
PyValue String 
PyValue JSValue 
PyValue PyValueEx 
PyValue Protocol

PyValue instance of Protocol

This instance is used by the Haskell to Python constants

PyValue PythonNone 
PyValue PythonChar 
PyValue DiskTemplate 
PyValue VerifyOptionalChecks 
PyValue CVErrorCode 
PyValue Hypervisor 
PyValue ExportMode 
PyValue VType 
PyValue DiskIndex 
PyValue INicParams 
PyValue RecreateDisksInfo 
PyValue IDiskParams 
PyValue a => PyValue [a] 
PyValue a => PyValue (JSObject a) 
PyValue a => PyValue (ListSet a) 
PyValue a => PyValue (FrozenSet a)

Converts a Haskell Set into a Python frozenset

This instance was supposed to be for Set instead of FrozenSet. However, 'ghc-6.12.1' seems to be crashing with 'segmentation fault' due to the presence of more than one instance of Set, namely, this one and the one in OpCodes. For this reason, we wrap Set into FrozenSet.

PyValue a => PyValue (NonEmpty a) 
PyValue a => PyValue (NonNegative a) 
PyValue a => PyValue (SetParamsMods a) 
(PyValue a, PyValue b) => PyValue (a, b) 
(PyValue k, PyValue a) => PyValue (Map k a) 
(PyValue a, PyValue b, PyValue c) => PyValue (a, b, c) 

data PyValueEx Source

Encapsulates Python default values


forall a . PyValue a => PyValueEx a 


type OpCodeDescriptor = (String, String, String, [String], [String], [Maybe PyValueEx], [String], String)Source

Transfers opcode data between the opcode description (through genOpCode) and the Python code generation functions.

pyBaseName :: String -> StringSource

pyTypeName :: Show a => a -> StringSource

pyType :: Type -> Q StringSource

pyCall :: Type -> Type -> Q StringSource

pyOptionalType :: Bool -> Type -> Q StringSource

maybeApp :: Maybe (Q Exp) -> Q Type -> Q ExpSource

genPyType :: OptionalType -> Q Type -> Q ExpQSource

genPyTypes :: [Field] -> Q ExpQSource

opcodeConsToLuxiCons :: (a, b, c, d, e) -> (a, d)Source



:: String

Type name to use

-> [OpCodeConstructor]

Constructor name and parameters

-> Q [Dec] 

Generates the OpCode data type.

This takes an opcode logical definition, and builds both the datatype and the JSON serialisation out of it. We can't use a generic serialisation since we need to be compatible with Ganeti's own, so we have a few quirks to work around.

genAllOpFields :: String -> [OpCodeConstructor] -> (Dec, Dec)Source

genSaveOpCode :: Name -> String -> String -> [LuxiConstructor] -> (LuxiConstructor -> Q Clause) -> Bool -> Q [Dec]Source

Template code for luxi

genStrOfOp :: Name -> String -> Q [Dec]Source

Constructor-to-string for LuxiOp.

genStrOfKey :: Name -> String -> Q [Dec]Source

Constructor-to-string for MsgKeys.

genLuxiOp :: String -> [LuxiConstructor] -> Q [Dec]Source

Generates the LuxiOp data type.

This takes a Luxi operation definition and builds both the datatype and the function transforming the arguments to JSON. We can't use anything less generic, because the way different operations are serialized differs on both parameter- and top-level.

There are two things to be defined for each parameter:

  • name
  • type

Objects functionality

fieldTypeInfo :: String -> Field -> Q (Name, Strict, Type)Source

buildObject :: String -> String -> [Field] -> Q [Dec]Source

Build an object declaration.

buildObjectSerialisation :: String -> [Field] -> Q [Dec]Source

Generates an object definition: data type and its JSON instance.

toDictName :: String -> NameSource

genSaveObject :: (Name -> Field -> Q Exp) -> String -> [Field] -> Q [Dec]Source

saveObjectField :: Name -> Field -> Q ExpSource

objectShowJSON :: String -> Q DecSource

genLoadObject :: (Field -> Q (Name, Stmt)) -> String -> [Field] -> Q (Dec, Dec)Source

loadObjectField :: Field -> Q (Name, Stmt)Source

objectReadJSON :: String -> Q DecSource

Inheritable parameter tables implementation

paramTypeNames :: String -> (String, String)Source

paramFieldTypeInfo :: String -> Field -> Q (Name, Strict, Type)Source

buildParam :: String -> String -> [Field] -> Q [Dec]Source

Build a parameter declaration.

This function builds two different data structures: a filled one, in which all fields are required, and a partial one, in which all fields are optional. Due to the current record syntax issues, the fields need to be named differrently for the two structures, so the partial ones get a P suffix.

buildParamAllFields :: String -> [Field] -> [Dec]Source

buildDictObjectInst :: Name -> String -> [Dec]Source

buildPParamSerialisation :: String -> [Field] -> Q [Dec]Source

savePParamField :: Name -> Field -> Q ExpSource

loadPParamField :: Field -> Q (Name, Stmt)Source

buildFromMaybe :: String -> Q DecSource

fillParam :: String -> String -> [Field] -> Q [Dec]Source

Template code for exceptions

excErrMsg :: (String, Q Type)Source

Exception simple error message field.



:: String

Name of new type

-> SimpleObject

Constructor name and parameters

-> Q [Dec] 

Builds an exception type definition.

saveExcCons :: String -> [SimpleField] -> Q ClauseSource

loadExcConstructor :: Name -> String -> [SimpleField] -> Q ExpSource

genLoadExc :: Name -> String -> SimpleObject -> Q (Dec, Dec)Source