Documentation

Generates a JSON instance for a given type.

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

Transforms a CamelCase string into an_underscore_based_one.

Constructor-to-string for OpCode.

Strips Op from the constructor name, converts to lower-case and adds a given prefix.

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.

Generates a list of all defined opcode IDs.

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.

Encapsulates Python default values

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

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.

Constructor-to-string for LuxiOp.

Constructor-to-string for MsgKeys.

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

Serialised field data type describing how to generate code for the field. Each field has a type, which isn't captured in the type of the data type, but is saved in the Q monad in fieldType.

Let t be a type we want to parametrize the field with. There are the following possible types of fields:

Mandatory with no default.

Then fieldType holds t, fieldDefault = Nothing and fieldIsOptional = NotOptional.

Field with a default value.

Then fieldType holds t and fieldDefault = Just exp where exp is an expression of type t and fieldIsOptional = NotOptional.

Optional, no default value.

Then fieldType holds Maybe t, fieldDefault = Nothing and fieldIsOptional is either OptionalOmitNull or OptionalSerializeNull.

Optional fields with a default value are prohibited, as their main intention is to represent the information that a request didn't contain the field data.

Custom (de)serialization: Field can have custom (de)serialization functions that are stored in fieldRead and fieldShow. If they aren't provided, the default is to use readJSON and showJSON for the field's type t. If they are provided, the type of the contained deserializing expression must be

  [(String, JSON.JSValue)] -> JSON.JSValue -> JSON.Result t

where the first argument carries the whole record in the case the deserializing function needs to process additional information.

The type of the contained serializing experssion must be

  t -> (JSON.JSValue, [(String, JSON.JSValue)])

where the result can provide extra JSON fields to include in the output record (or just return [] if they're not needed).

Note that for optional fields the type appearing in the custom functions is still t. Therefore making a field optional doesn't change the functions.

There is also a special type of optional field AndRestArguments which allows to parse any additional arguments not covered by other fields. There can be at most one such special field and it's type must be Map String JSON.JSValue. See also andRestArguments.

Generates a simple field.

Generate an AndRestArguments catch-all field.

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

A defaultField which will be serialized only if it's value differs from a default value.

Mark a field as present in the forthcoming variant.

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

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

Make a field optional, if it isn't already.

Sets the renamed constructor field.

Sets custom functions on a field.

Build an object declaration.

Build an object that can have a forthcoming variant. This will create 3 data types: two objects, prefixed by Real and Forthcoming, respectively, and a sum type of those. The JSON representation of the latter will be a JSON object, dispatching on the "forthcoming" key.

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

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. Also generate a default value for the partial parameters.

Builds an exception type definition.

Exception simple error message field.

Compute the ssconf constructor name from its file name.