202 lines
6.6 KiB
Plaintext
202 lines
6.6 KiB
Plaintext
Variables créole
|
|
================
|
|
|
|
typeole_
|
|
|
|
.. _typeole: api/creole.typeole-module.html
|
|
|
|
variable créole
|
|
|
|
instance d'un objet type eole, à un nom de variable correspond
|
|
peut-être plusieurs valeurs
|
|
|
|
>>> from creole import typeole
|
|
>>> var = typeole.EoleVar('mavariable')
|
|
>>> var.val
|
|
[]
|
|
>>> var.set_value('valeur')
|
|
>>> var.set_value('defaut', default=True)
|
|
>>> var.val
|
|
['valeur']
|
|
>>> var.valdefault
|
|
['defaut']
|
|
>>> var.description = 'variable de test'
|
|
>>> var.description
|
|
'variable de test'
|
|
>>>
|
|
|
|
il est possible de créer une variable Eole à l'aide
|
|
d'une factory :
|
|
|
|
>>> var2 = typeole.type_factory('string', 'test_string', valeole=["eole"], valdefault=["def"])
|
|
>>> var2.get_value()
|
|
['def']
|
|
>>>
|
|
|
|
des vérifications de type sont faites au moment du *set_value()*
|
|
|
|
collecte des variables créole
|
|
-----------------------------
|
|
|
|
collecte
|
|
|
|
Récupération de variables qui serviront a la constitution du dictionnaire Eole
|
|
|
|
Les données du dictionnaire sont collectées à partir de différents fichiers dans un premier format XML.
|
|
|
|
sur une machine cible, une collecte des variables eole est faite avec parse_dico_::
|
|
|
|
from creole.parsedico import parse_dico
|
|
parse_dico()
|
|
|
|
.. ce test n'est pas lancé car il peut y avoir un dico sur le poste
|
|
de travail
|
|
|
|
.. _parse_dico: api/creole.parsedico-module.html
|
|
|
|
Le dictionnaire créole est vide. Pour le remplir, il faut
|
|
récupérer des données depuis un fichier xml initial::
|
|
|
|
my_dict = EoleDict()
|
|
my_dict.read(join('/etc/eole/','eole.xml'))
|
|
|
|
.. TODO: read_string(self, xml_string)
|
|
|
|
Utilisation du dictionnaire
|
|
---------------------------
|
|
|
|
dictionnaire
|
|
|
|
fichier au format xml contenant :
|
|
- une liste de fichiers
|
|
- une liste de variables
|
|
|
|
famille
|
|
|
|
Il s'agit d'un regroupement de variable utilisé pour la saisie : on parle alors de famille de variables
|
|
|
|
groupe
|
|
|
|
Il s'agit de variables de type `liste` dont les éléments sont liées aux éléments correspondants des autres
|
|
eth[2] aura un lien avec netmask[2] et network[2].
|
|
|
|
Plutôt que d'utiliser `parsedico`, construisons un dictionnaire creole EoleDict_ :
|
|
|
|
>>> from creole import cfgparser
|
|
>>> from creole import typeole
|
|
>>>
|
|
>>> dico = cfgparser.EoleDict()
|
|
>>> dico.variables['ip_eth'] = typeole.type_factory('string', 'ip_eth', val=['ip0', 'ip1', 'ip2'])
|
|
>>> dico.variables['nom_etab'] = typeole.type_factory('string', 'nom_etab', val=['etab'])
|
|
>>> dico.variables['vrai'] = typeole.type_factory('boolean', 'vrai', val=[True])
|
|
>>> dico.variables['faux'] = typeole.type_factory('string', 'faux', val=['faux'])
|
|
>>> dico.variables['toto'] = typeole.type_factory('string', 'toto', val=['toto'])
|
|
|
|
voici comment accéder aux variables créole
|
|
|
|
>>> assert dico.get_value('ip_eth') == ['ip0', 'ip1', 'ip2']
|
|
>>> assert dico.get_value('nom_etab') == ['etab']
|
|
|
|
.. _EoleDict : api/creole.cfgparser.EoleDict-class.html
|
|
|
|
|
|
variables de template
|
|
-----------------------
|
|
|
|
|
|
lorsqu'on utilise un appel de bas niveau de traitement de template,
|
|
c'est-à-dire l'appel direct à la
|
|
méthode process_ d'un template, il faut vérifier qu'une variable
|
|
est bien instanciée avec le bon contexte de dictionnaire :
|
|
|
|
.. _process: api/creole.template.Template-class.html
|
|
|
|
>>> from creole.cfgparser import EoleDict
|
|
>>> from creole import typeole
|
|
>>> from creole.template import Template
|
|
>>> dico = EoleDict()
|
|
>>> dico.variables['toto'] = typeole.type_factory('string',
|
|
... 'toto', val=['toto'], context=dico)
|
|
>>> t = Template('data/dst/test.tmpl', templatedir= 'data/src')
|
|
>>> t.verify()
|
|
>>> t.process(dico)
|
|
>>> f = open('data/dst/test.tmpl')
|
|
>>> res = f.read()
|
|
>>> f.close()
|
|
>>> assert 'titi' not in res
|
|
>>> dico.set_value('toto', 'titi')
|
|
>>> t.process(dico)
|
|
>>> f = open('data/dst/test.tmpl')
|
|
>>> res = f.read()
|
|
>>> f.close()
|
|
>>> assert 'titi' in res
|
|
|
|
le contexte `dico` est passé à la variable `toto`::
|
|
|
|
dico.variables['toto'] = typeole.type_factory('string',
|
|
'toto', val=['toto'], context=dico)
|
|
|
|
variables automatiques
|
|
----------------------
|
|
|
|
variable automatique
|
|
|
|
variable présente dans le dictionnaire xml mais pas dans le fichier *.ini* de configuration.
|
|
la valeur de cette variable (sont appel à *.get_value()* est soumis à une fonction de traitement
|
|
spécifiée dans le xml, qui calcule la variable au lieu de formater sa valeur.
|
|
|
|
Une variable automatique simple n'est pas traitée différemment d'une variable dont la valeur est présente dans le dictionnaire et qui est soumise à une condition de vérification de sa valeur. Simplement, aucune vérification n'est effectuée et la valeur est calculée.
|
|
|
|
déclaration de la variable::
|
|
|
|
<variable name='server_mem' type='string' description='memoire du serveur' auto='True' />
|
|
|
|
déclaration de la fonction de remplissage::
|
|
|
|
<fill name='server_mem' target='server_mem' />
|
|
|
|
deux fonctions strictement automatiques sont implémentées: `server_mem` et `kernel_version`
|
|
|
|
variable semi-automatique
|
|
|
|
variable remplit automatiquement dans le cas d'une condition sur une autre variable,
|
|
si cette condition n'est pas remplie, c'est l'uilisateur qui la remplit (ou une autre fonction).
|
|
la condition est traitée à deux niveaux, dans la fonction de remplissage, et au niveau de l'affichage.
|
|
On remplit donc deux fonctions pour ce conditionnement (une fonction fill avec la variable
|
|
conditionnante en paramètre et une fonction condition qui conditionne l'affichage de la variable.
|
|
exemple : récupération des adresses eth dans le cas où l'on a pas de dhcp.
|
|
|
|
déclaration de la variable semi-auto::
|
|
|
|
<variable name='eth0' type='string' auto='True'/>
|
|
|
|
déclaration de la variable qui définit la condition::
|
|
|
|
<variable name='dhcp' type='boolean' description='Activation du dhcp' >
|
|
<value>non</value>
|
|
</variable>
|
|
<check name='valid_enum' target='dhc'>
|
|
<param>['oui','non']</param>
|
|
</check>
|
|
|
|
déclaration de la fonction de contrôle d'automatisme, la variable eth0 est remplie automatiquement par la fonction
|
|
*auto_eth* si le paramètre dhcp est égal à la condition *oui*::
|
|
|
|
<fill name='auto_eth' target='eth0'>
|
|
<param>eth0</param>
|
|
<param name='condition'>oui</param>
|
|
<param type='eole' name='parametre'>dhcp</param>
|
|
</fill>
|
|
|
|
déclaration de la fonction de contrôle d'éditabilité::
|
|
|
|
<condition name='hidden_if_in' source='dhc'>
|
|
<param>oui</param>
|
|
<target type='variable'>eth0</target>
|
|
</condition>
|
|
|
|
pour l'instant sont diposnible auto_eth, auto_netmask, auto_broadcast et auto_network.
|
|
|
|
|
|
|