736 lines
32 KiB
Python
736 lines
32 KiB
Python
#!/usr/bin/env python
|
|
#-*- coding: utf-8 -*-
|
|
"""
|
|
|
|
Utilitaire de mise à jour des variables
|
|
pour les versions >= 2.4.1
|
|
|
|
"""
|
|
from .upgrade import log, migration_23_to_tiramisu
|
|
from .var_loader import convert_value
|
|
from pyeole.i18n import i18n
|
|
from tiramisu.setting import owners
|
|
from tiramisu.setting import undefined
|
|
from distutils.version import StrictVersion
|
|
from pyeole.encode import normalize
|
|
_ = i18n('creole')
|
|
|
|
class Upgrade():
|
|
"""
|
|
Méthodes pour la mise à niveau des variables
|
|
"""
|
|
def __init__(self, config):
|
|
owner = u'upgrade'
|
|
if owner not in dir(owners):
|
|
owners.addowner(owner)
|
|
self.config = config
|
|
self.owner = getattr(owners, owner)
|
|
self.unknown_options = config.impl_get_information(u'unknown_options')
|
|
|
|
def get_old_value(self, variable, old_variable, default=None):
|
|
"""
|
|
Retourne la valeur d'une variable "disparue"
|
|
"""
|
|
try:
|
|
old_obj = self.unknown_options[old_variable]
|
|
if old_obj.get('old_format', False):
|
|
try:
|
|
path = self.get_path(variable)
|
|
except AttributeError:
|
|
return default
|
|
opt = self.config.unwrap_from_path(path)
|
|
val = migration_23_to_tiramisu(opt, old_obj['val'])
|
|
else:
|
|
val = old_obj['val']
|
|
return val
|
|
except KeyError:
|
|
return default
|
|
|
|
def get_value(self, variable, default=None):
|
|
"""
|
|
Retourne la valeur d'une variable "connue"
|
|
"""
|
|
try:
|
|
path = self.get_path(variable)
|
|
except AttributeError:
|
|
return default
|
|
return self.config.getattr(path,
|
|
force_permissive=True)
|
|
|
|
def get_unvalid_value(self, variable, default=None):
|
|
try:
|
|
path = self.get_path(variable)
|
|
except AttributeError:
|
|
return default
|
|
try:
|
|
return self.config.impl_get_information('orig_value_{}'.format(path))
|
|
except ValueError:
|
|
return default
|
|
|
|
def get_noncalculated_value_for_auto(self, variable):
|
|
"""
|
|
Retourne la valeur contenue dans le fichier config.eol dans le cas où la variable
|
|
est calculée (auto), forcé à la valeur par défaut, ...
|
|
"""
|
|
try:
|
|
path = self.get_path(variable)
|
|
except AttributeError:
|
|
log.error(_('get_noncalculated_value_for_auto: unknown variable {}').format(variable))
|
|
return None
|
|
values = self.config.cfgimpl_get_values()
|
|
if values._contains(path):
|
|
idx = 0
|
|
vals = []
|
|
while True:
|
|
val = values._p_.getvalue(path, values._p_.getsession(), idx)
|
|
if val is undefined:
|
|
break
|
|
vals.append(val)
|
|
idx += 1
|
|
if len(vals) > 0:
|
|
return vals
|
|
else:
|
|
return None
|
|
return None
|
|
|
|
def var_exists(self, variable):
|
|
try:
|
|
self.get_path(variable)
|
|
return True
|
|
except AttributeError:
|
|
return False
|
|
|
|
def get_path(self, variable):
|
|
"""
|
|
Retourne le chemin complet d'une variable
|
|
"""
|
|
return self.config.find_first(byname=variable, type_='path')
|
|
|
|
def modify_owner(self, path, value=None, index=None):
|
|
"""
|
|
Modifie le propriétaire d'une variable
|
|
"""
|
|
option = self.config.unwrap_from_path(path)
|
|
if option.impl_is_master_slaves('slave'):
|
|
if index is not None:
|
|
self.config.cfgimpl_get_values().setowner(option,
|
|
self.owner,
|
|
index=index)
|
|
elif value is not None:
|
|
for idx in xrange(len(value)):
|
|
self.config.cfgimpl_get_values().setowner(option,
|
|
self.owner,
|
|
index=idx)
|
|
else:
|
|
raise Exception('must have value or index for slave')
|
|
|
|
else:
|
|
self.config.cfgimpl_get_values().setowner(option,
|
|
self.owner)
|
|
|
|
def is_default(self, variable, default=True):
|
|
"""
|
|
Retourne True si la valeur n'a pas été personnalisée par l'utilisateur
|
|
"""
|
|
try:
|
|
path = self.get_path(variable)
|
|
except AttributeError:
|
|
return default
|
|
option = self.config.unwrap_from_path(path)
|
|
return self.config.cfgimpl_get_values().is_default_owner(option)
|
|
|
|
def set_value(self, variable, value):
|
|
"""
|
|
Modifie la valeur d'une variable
|
|
"""
|
|
try:
|
|
path = self.get_path(variable)
|
|
except AttributeError:
|
|
log.error(_(u"Try to set value to unknown option: {0} = {1}").format(variable, value))
|
|
else:
|
|
try:
|
|
self.config._setattr(path, value,
|
|
force_permissive=True)
|
|
self.modify_owner(path, value)
|
|
log.info(_(u"Variable updated: {0} = {1}").format(variable, value))
|
|
self.config.impl_del_information('error_msg_{}'.format(path), raises=False)
|
|
self.config.impl_del_information('orig_value_{}'.format(path), raises=False)
|
|
option = self.config.unwrap_from_path(path)
|
|
self.config.cfgimpl_get_settings()[option].remove('load_error')
|
|
except ValueError:
|
|
option = self.config.unwrap_from_path(path)
|
|
try:
|
|
# the value could be in Creole 2.3 format #13957
|
|
if not option.impl_is_multi() and isinstance(value, list) and len(value) == 1:
|
|
value = value[0]
|
|
if value in ['', ['']]:
|
|
err_msg = _(u"empty value")
|
|
log.error(_(u"{0} for {1}").format(err_msg, variable))
|
|
return
|
|
self.config._setattr(path, convert_value(option, value),
|
|
force_permissive=True)
|
|
self.modify_owner(path, value)
|
|
log.info(_(u"Variable updated: {0} = {1}").format(variable, value))
|
|
except Exception, err:
|
|
log.error(_(u"{0} for {1}").format(err, variable))
|
|
self.config.cfgimpl_get_settings()[option].append('load_error')
|
|
except Exception, err:
|
|
option = self.config.unwrap_from_path(path)
|
|
log.error(_("{0} for {1}").format(normalize(str(err)), variable))
|
|
self.config.cfgimpl_get_settings()[option].append('load_error')
|
|
|
|
def del_value(self, variable):
|
|
try:
|
|
path = self.get_path(variable)
|
|
except AttributeError:
|
|
log.error(_('Try to delete an unknown option: {0}').format(variable))
|
|
else:
|
|
option = self.config.unwrap_from_path(path)
|
|
self.config.cfgimpl_get_values().__delitem__(option)
|
|
log.info(_(u"Variable {0} reinitialized").format(variable))
|
|
|
|
def append_value(self, variable, value):
|
|
"""
|
|
Ajoute une valeur à une variable multi
|
|
"""
|
|
try:
|
|
path = self.get_path(variable)
|
|
except AttributeError:
|
|
log.error(_('Try to append a value to an unknown option: {0} += {1}').format(variable, value))
|
|
else:
|
|
multi = self.config.getattr(path,
|
|
force_permissive=True)
|
|
multi.append(value)
|
|
self.modify_owner(path, index=len(multi) - 1)
|
|
|
|
def modify_last_value(self, variable, value):
|
|
"""
|
|
Modifie la dernière valeur d'une variable multi
|
|
"""
|
|
try:
|
|
path = self.get_path(variable)
|
|
except AttributeError:
|
|
log.error(_('Try to modify last value of an unknown option: {0}[-1] = {1}').format(variable, value))
|
|
else:
|
|
multi = self.config.getattr(path,
|
|
force_permissive=True)
|
|
multi[-1] = value
|
|
self.modify_owner(path, index=len(multi) - 1)
|
|
|
|
def move(self, old_variable, new_variable):
|
|
"""
|
|
Déplace les données d'une variable "disparue"
|
|
vers une nouvelle variable
|
|
"""
|
|
if old_variable in self.unknown_options:
|
|
value = self.unknown_options[old_variable][u'val']
|
|
path = self.get_path(new_variable)
|
|
option = self.config.unwrap_from_path(path)
|
|
if value in ['', ['']]:
|
|
err_msg = _(u"empty value")
|
|
log.error(_(u"{0} for {1}").format(err_msg, old_variable))
|
|
return
|
|
if option.impl_is_multi() and isinstance(value, list):
|
|
for val in value:
|
|
self.append_value(new_variable, val)
|
|
else:
|
|
self.set_value(new_variable, value)
|
|
del(self.unknown_options[old_variable])
|
|
log.info(_(u"Variable {0} has been renamed to {1}").format(old_variable, new_variable))
|
|
|
|
def copy(self, old_variable, new_variable, only_if_modified=True):
|
|
"""
|
|
Copie la valeur d'une variable existante vers une autre
|
|
Si la valeur "old" est une multi et pas la "new" => copie la 1er valeur de la liste
|
|
Si la valeur "old" n'est pas une multi et la "new" ne l'est pas => transforme la valeur en liste
|
|
only_if_modified: si True ne copie que les valeurs qui sont modifiées
|
|
"""
|
|
try:
|
|
# si les deux variables existe => migration
|
|
old_path = self.get_path(old_variable)
|
|
new_path = self.get_path(new_variable)
|
|
except AttributeError:
|
|
pass
|
|
else:
|
|
old_option = self.config.unwrap_from_path(old_path)
|
|
new_option = self.config.unwrap_from_path(new_path)
|
|
# si la nouvelle option n'est pas modifié et si la valeur est modifié ou only_if_modified est False
|
|
if self.config.cfgimpl_get_values().is_default_owner(new_option) and \
|
|
(not only_if_modified or
|
|
not self.config.cfgimpl_get_values().is_default_owner(old_option)):
|
|
old_value = self.config.getattr(old_path,
|
|
force_permissive=True)
|
|
if old_option.impl_is_multi() and not new_option.impl_is_multi():
|
|
if len(old_value) != 0:
|
|
old_value = old_value[0]
|
|
else:
|
|
old_value = None
|
|
if not old_option.impl_is_multi() and new_option.impl_is_multi():
|
|
if old_value is None:
|
|
old_value = []
|
|
else:
|
|
old_value = [old_value]
|
|
self.set_value(new_variable, old_value)
|
|
|
|
|
|
|
|
class Upgrade_2_4_1(Upgrade):
|
|
"""
|
|
Mise à jour d'une configuration
|
|
de 2.4.0 vers 2.4.1
|
|
"""
|
|
|
|
def run(self):
|
|
"""
|
|
Lancement des traitements
|
|
"""
|
|
log.info(_(u"Starting {0} to {1} upgrade").format('2.4.0', '2.4.1'))
|
|
|
|
# renommage des variables "era_proxy_bypass"
|
|
for i in range(1, 5):
|
|
self.move('era_proxy_bypass_eth{0}'.format(i), 'proxy_bypass_network_eth{0}'.format(i))
|
|
|
|
# fusion des variables "proxy_bypass" et "wpad_exclude"
|
|
if 'adresse_ip_wpad_exclude' in self.unknown_options:
|
|
#le 1er argument sert a récupérer les propriétés des option (choiceoption, multi, ...)
|
|
#on lui passe la variable de la 1er interface
|
|
old_interfaces = self.get_old_value('proxy_bypass_network_eth1', 'interface_wpad_exclude')
|
|
netmasks = self.get_old_value('proxy_bypass_netmask_eth1', 'adresse_netmask_wpad_exclude')
|
|
for idx, value in enumerate(self.get_old_value('proxy_bypass_network_eth1', 'adresse_ip_wpad_exclude')):
|
|
interface = old_interfaces[idx]
|
|
if interface == 'Toutes':
|
|
interfaces = range(1, 5)
|
|
elif int(interface) in range(1, 5):
|
|
interfaces = [interface]
|
|
else:
|
|
log.error(_(u"Invalid value : {0} in old variable {1}").format(interface, 'interface_wpad_exclude'))
|
|
continue
|
|
for i in interfaces:
|
|
self.append_value('proxy_bypass_network_eth{0}'.format(i), value)
|
|
self.modify_last_value('proxy_bypass_netmask_eth{0}'.format(i), netmasks[idx])
|
|
del(self.unknown_options['adresse_ip_wpad_exclude'])
|
|
del(self.unknown_options['adresse_netmask_wpad_exclude'])
|
|
del(self.unknown_options['interface_wpad_exclude'])
|
|
|
|
# passage à oui des variables "proxy_bypass_ethX" si nécessaire
|
|
for i in range(1, 5):
|
|
if len(self.get_value('proxy_bypass_network_eth{0}'.format(i), [])) > 0:
|
|
self.set_value('proxy_bypass_eth{0}'.format(i), u'oui')
|
|
|
|
# transfert des variables nom_domaine_wpad_exclude
|
|
if 'nom_domaine_wpad_exclude' in self.unknown_options:
|
|
old_interfaces = self.get_old_value('proxy_bypass_domain_eth1', 'nom_interface_wpad_exclude')
|
|
for idx, value in enumerate(self.get_old_value('proxy_bypass_domain_eth1', 'nom_domaine_wpad_exclude')):
|
|
interface = old_interfaces[idx]
|
|
if interface == 'Toutes':
|
|
interfaces = range(1, 5)
|
|
elif int(interface) in range(1, 5):
|
|
interfaces = [interface]
|
|
else:
|
|
log.error(_(u"Invalid value : {0} in old variable {1}").format(interface, 'nom_interface_wpad_exclude'))
|
|
continue
|
|
for i in interfaces:
|
|
self.append_value('proxy_bypass_domain_eth{0}'.format(i), value)
|
|
del(self.unknown_options['nom_domaine_wpad_exclude'])
|
|
del(self.unknown_options['nom_interface_wpad_exclude'])
|
|
|
|
# nom_serveur_scribe_dmz/ip_serveur_scribe_dmz => mandatory (#11713)
|
|
if self.get_value('install_scribe_dmz') == u'oui':
|
|
if self.get_value('nom_serveur_scribe_dmz') == None or self.get_value('ip_serveur_scribe_dmz') == None:
|
|
self.set_value('install_scribe_dmz', u'non')
|
|
|
|
|
|
class Upgrade_2_4_2(Upgrade):
|
|
"""
|
|
Mise à jour d'une configuration
|
|
de 2.4.1 vers 2.4.2
|
|
"""
|
|
|
|
def run(self):
|
|
"""
|
|
Lancement des traitements
|
|
"""
|
|
log.info(_(u"Starting {0} to {1} upgrade").format('2.4.1', '2.4.2'))
|
|
# migration des variables eolesso vers client LDAP #10821
|
|
self.copy('eolesso_port_ldap', 'ldap_port')
|
|
self.copy('eolesso_ldap_reader', 'ldap_reader')
|
|
self.copy('eolesso_ldap_reader_passfile', 'ldap_reader_passfile')
|
|
self.copy('eolesso_ldap_match_attribute', 'ldap_match_attribute')
|
|
self.copy('eolesso_ldap_filter_user', 'ldap_filter_user')
|
|
self.copy('eolesso_ldap_filter_group', 'ldap_filter_group')
|
|
self.copy('eolesso_ldap_dntree_user', 'ldap_dntree_user')
|
|
self.copy('eolesso_ldap_dntree_group', 'ldap_dntree_group')
|
|
self.copy('eolesso_ldap_fill_displayname', 'ldap_fill_displayname')
|
|
self.copy('eolesso_ldap_fill_mail', 'ldap_fill_mail')
|
|
self.copy('eolesso_ldap_fill_fonction', 'ldap_fill_fonction')
|
|
self.copy('eolesso_ldap_fill_categorie', 'ldap_fill_categorie')
|
|
self.copy('eolesso_ldap_fill_rne', 'ldap_fill_rne')
|
|
self.copy('eolesso_ldap_fill_fredurne', 'ldap_fill_fredurne')
|
|
self.copy('eolesso_ldap_fill_displaygroup', 'ldap_fill_displaygroup')
|
|
|
|
# migration des variables courier #10987
|
|
courier_val = self.get_old_value('activer_recuperation_courriel', 'activer_courier')
|
|
if courier_val is not None:
|
|
if courier_val == 'non':
|
|
self.set_value('activer_recuperation_courriel', 'non')
|
|
elif not 'imap' in courier_val:
|
|
self.set_value('activer_courier_imap', 'non')
|
|
if 'pop' in courier_val:
|
|
self.set_value('activer_courier_pop', 'oui')
|
|
|
|
|
|
class Upgrade_2_5_0(Upgrade):
|
|
"""
|
|
Mise à jour d'une configuration
|
|
de 2.4.X vers 2.5.0
|
|
"""
|
|
|
|
def run(self):
|
|
"""
|
|
Lancement des traitements
|
|
"""
|
|
log.info(_(u"Starting {0} to {1} upgrade").format('2.4.X', '2.5.0'))
|
|
|
|
# migration des variables nut #11608
|
|
monitor = self.get_value('nut_monitor_user')
|
|
if monitor != []:
|
|
self.set_value('nut_monitor', 'oui')
|
|
|
|
# migration des variables postgresql pour Zéphir #11974
|
|
old_pg_shared_buffers = self.get_value('pg_shared_buffers')
|
|
if old_pg_shared_buffers is not None:
|
|
if int(old_pg_shared_buffers) == 3072:
|
|
self.del_value('pg_shared_buffers')
|
|
else:
|
|
self.set_value('pg_shared_buffers_unit', u'kB')
|
|
self.del_value('pg_effective_cache_size')
|
|
|
|
|
|
class Upgrade_2_5_1(Upgrade):
|
|
"""
|
|
Mise à jour d'une configuration
|
|
de 2.5.0 vers 2.5.1
|
|
"""
|
|
|
|
def run(self):
|
|
"""
|
|
Lancement des traitements
|
|
"""
|
|
log.info(_(u"Starting {0} to {1} upgrade").format('2.5.0', '2.5.1'))
|
|
|
|
# migration des variables zone_forward (#11922)
|
|
zone_forward = self.get_value('nom_zone_forward', [])
|
|
if zone_forward != []:
|
|
self.set_value('activer_zone_forward', 'oui')
|
|
|
|
# passage de bacula à bareos (#12425)
|
|
for var in ['activer_bareos_dir', 'activer_bareos_sd',
|
|
'bareos_dir_name', 'bareos_full_retention',
|
|
'bareos_full_retention_unit', 'bareos_diff_retention',
|
|
'bareos_diff_retention_unit', 'bareos_inc_retention',
|
|
'bareos_inc_retention_unit', 'bareos_max_run_time',
|
|
'bareos_compression', 'bareos_dir_password',
|
|
'bareos_fd_password', 'bareos_sd_local',
|
|
'bareos_sd_adresse', 'bareos_sd_password',
|
|
'bareos_sd_name', 'bareos_sd_remote_dir_name',
|
|
'bareos_sd_remote_ip', 'bareos_sd_remote_password']:
|
|
self.move(var.replace('bareos', 'bacula'), var)
|
|
|
|
if self.get_value('activer_bareos_dir') == u'oui':
|
|
#sauvegarde déjà programmé en sqlite3, ne gère pas la migration vers mysql
|
|
self.set_value('bareos_db_type', 'sqlite3')
|
|
|
|
if self.get_value('ldap_ca_cert') == '/etc/certs/CA2008.pem':
|
|
self.set_value('ldap_ca_cert', '/etc/certs/certificat.pem')
|
|
|
|
|
|
class Upgrade_2_5_2(Upgrade):
|
|
"""
|
|
Mise à jour d'une configuration
|
|
de 2.5.1 vers 2.5.2
|
|
"""
|
|
|
|
def run(self):
|
|
"""
|
|
Lancement des traitements
|
|
"""
|
|
log.info(_(u"Starting {0} to {1} upgrade").format('2.5.1', '2.5.2'))
|
|
|
|
# haute dispo présente
|
|
if self.var_exists('activer_haute_dispo'):
|
|
# migration HD sphynx #14881
|
|
if self.var_exists('activer_resource_arv'):
|
|
activer_haute_dispo = self.get_value('activer_haute_dispo')
|
|
if activer_haute_dispo == 'maitre':
|
|
service_resource_name = self.get_noncalculated_value_for_auto('service_resource_name')
|
|
service_resource_startdelay = self.get_noncalculated_value_for_auto('service_resource_startdelay')
|
|
need_update = False
|
|
startdelay_index = 1
|
|
need_disabled_arv = False
|
|
if service_resource_startdelay is not None:
|
|
if service_resource_name is not None:
|
|
need_update = 'arv_rsc' in service_resource_name
|
|
if need_update:
|
|
startdelay_index = service_resource_name.index('arv_rsc')
|
|
need_disabled_arv = not need_update
|
|
else:
|
|
need_update = True
|
|
self.del_value('service_resource_name')
|
|
self.del_value('service_resource_script')
|
|
self.del_value('service_resource_interval')
|
|
self.del_value('service_resource_timeout')
|
|
self.del_value('service_resource_startdelay')
|
|
if need_update and service_resource_startdelay[startdelay_index] != 15:
|
|
self.set_value('service_resource_arv_startdelay', service_resource_startdelay[startdelay_index])
|
|
if need_disabled_arv:
|
|
self.set_value('activer_resource_arv', u'non')
|
|
#
|
|
vip_resource_adresseip = self.get_noncalculated_value_for_auto('vip_resource_adresseip')
|
|
self.del_value('vip_resource_name')
|
|
self.del_value('vip_resource_if')
|
|
self.del_value('vip_resource_adresseip')
|
|
self.del_value('vip_resource_location')
|
|
if vip_resource_adresseip is not None:
|
|
if len(vip_resource_adresseip) > 0:
|
|
self.set_value('vip_externe', vip_resource_adresseip[0])
|
|
if len(vip_resource_adresseip) > 1:
|
|
self.set_value('vip_interne', vip_resource_adresseip[1])
|
|
# migration HD non Sphynx #14951
|
|
else:
|
|
vip_resource_if = self.get_noncalculated_value_for_auto('vip_resource_if')
|
|
vip_netmask = []
|
|
for vip_if in vip_resource_if:
|
|
netmask_var = 'adresse_netmask_{0}'.format(vip_if.lower())
|
|
vip_netmask.append(self.get_value(netmask_var))
|
|
if len(vip_netmask) > 0:
|
|
self.set_value('vip_resource_netmask', vip_netmask)
|
|
service_resource_name = self.get_noncalculated_value_for_auto('service_resource_name')
|
|
if len(service_resource_name) > 0:
|
|
self.set_value('activer_service_resource', 'oui')
|
|
|
|
|
|
class Upgrade_2_6_0(Upgrade):
|
|
"""
|
|
Mise à jour d'une configuration
|
|
de 2.5.X vers 2.6.0
|
|
"""
|
|
|
|
def get_eth_no(self, eth):
|
|
"""
|
|
Retourne le numéro X du nom de l'interface ethX
|
|
"""
|
|
try:
|
|
return eth.split("eth")[1]
|
|
except:
|
|
log.error(_(u"Interface {0} name has not an 'ethX' format").format(eth))
|
|
|
|
def run(self):
|
|
"""
|
|
Lancement des traitements
|
|
"""
|
|
log.info(_(u"Starting {0} to {1} upgrade").format('2.5.X', '2.6.0'))
|
|
|
|
# migration des variables faisant référence au nom des interfaces ethX
|
|
eth_vars = ['route_int', 'fw_rule_int', 'dhcrelay_server_interface', 'freerad_listen_int',
|
|
'sw_force_ip_src', 'corosync_dial_if', 'dhcrelay_interfaces']
|
|
for eth_var in eth_vars:
|
|
eth_name = self.get_unvalid_value(eth_var)
|
|
if isinstance(eth_name, list):
|
|
eth_no = []
|
|
for eth in eth_name:
|
|
if eth == 'all':
|
|
eth_no.append(eth)
|
|
else:
|
|
eth_no.append(self.get_eth_no(eth))
|
|
if eth_no != [] and eth_no != eth_name:
|
|
self.set_value(eth_var, eth_no)
|
|
elif isinstance(eth_name, dict):
|
|
eth_no = []
|
|
for eth_key, eth_value in eth_name.items():
|
|
if eth_value == 'all':
|
|
eth_no.append(eth_value)
|
|
else:
|
|
eth_no.append(self.get_eth_no(eth_value))
|
|
if eth_no != [] and eth_no != eth_name:
|
|
self.set_value(eth_var, eth_no)
|
|
elif eth_name is not None:
|
|
eth_no = self.get_eth_no(eth_name)
|
|
self.set_value(eth_var, eth_no)
|
|
elif eth_var == 'dhcrelay_server_interface' and self.get_value('adresse_ip_dhcp_dhcrelay') is not None:
|
|
# migration de l'ancienne valeur par défaut de dhcrelay_server_interface #18329
|
|
self.set_value(eth_var, u'3')
|
|
# haute dispo présente
|
|
if self.var_exists('activer_haute_dispo'):
|
|
# migration HD non sphynx
|
|
if not self.var_exists('activer_resource_arv'):
|
|
eth_name = self.get_noncalculated_value_for_auto('vip_resource_if')
|
|
eth_no = []
|
|
for eth in eth_name:
|
|
eth_no.append(self.get_eth_no(eth))
|
|
self.set_value('vip_resource_if', eth_no)
|
|
|
|
|
|
class Upgrade_2_6_1(Upgrade):
|
|
"""
|
|
Mise à jour d'une configuration
|
|
de 2.6.0 vers 2.6.1
|
|
"""
|
|
|
|
def run(self):
|
|
"""
|
|
Lancement des traitements
|
|
"""
|
|
log.info(_(u"Starting {0} to {1} upgrade").format('2.6.0', '2.6.1'))
|
|
|
|
# migration des variables NTLM/SMB : multi -> non multi (#18277)
|
|
if self.var_exists('nom_serveur_smb'):
|
|
for varname in ('nom_serveur_smb', 'nom_domaine_smb', 'ip_serveur_smb'):
|
|
value = self.get_unvalid_value(varname)
|
|
if isinstance(value, list) and len(value) > 1:
|
|
self.set_value(varname, value[0])
|
|
|
|
# nom_carte_ethX => multi-valuées (#18609)
|
|
for numint in range(0, 5):
|
|
varname = 'nom_carte_eth{}'.format(numint)
|
|
value = self.get_unvalid_value(varname)
|
|
if value != None:
|
|
self.set_value(varname, [value])
|
|
|
|
# migration variable 'module_type' pour le module esbl ('ESBL') -> ('eSBL') (#21677)
|
|
if self.get_value('eole_module') == u'esbl':
|
|
self.set_value('module_type', u'eSBL')
|
|
|
|
|
|
class Upgrade_2_6_2(Upgrade):
|
|
"""
|
|
Mise à jour d'une configuration
|
|
de 2.6.1 vers 2.6.2
|
|
"""
|
|
|
|
def run(self):
|
|
"""
|
|
Lancement des traitements
|
|
"""
|
|
log.info(_(u"Starting {0} to {1} upgrade").format('2.6.1', '2.6.2'))
|
|
|
|
adresse_network_dhcp = self.get_value('adresse_network_dhcp')
|
|
if adresse_network_dhcp:
|
|
plages = []
|
|
for idx in xrange(len(adresse_network_dhcp)):
|
|
plages.append(u'plage{}'.format(idx))
|
|
self.set_value('nom_plage_dhcp', plages)
|
|
if self.var_exists('acces_distant_backend_ead'):
|
|
self.set_value('acces_distant_backend_ead', 'oui')
|
|
for interface in [str(n) for n in range(5)]:
|
|
variable = 'frontend_ead_distant_eth' + interface
|
|
if self.var_exists(variable):
|
|
self.set_value(variable, 'oui')
|
|
variable = 'ip_frontend_ead_distant_eth' + interface
|
|
if self.var_exists(variable):
|
|
self.set_value(variable, ['0.0.0.0'])
|
|
variable = 'netmask_frontend_ead_distant_eth' + interface
|
|
if self.var_exists(variable):
|
|
self.set_value(variable, ['0.0.0.0'])
|
|
# Upgrade Seth
|
|
# AD firewall - mix old multi variables ad_clients_ip and
|
|
# ad_servers_ip in ad_peer_ip
|
|
ad_servers_ip = self.get_old_value('ad_peer_ip', 'ad_servers_ip')
|
|
ad_clients_ip = self.get_old_value('ad_peer_ip', 'ad_clients_ip')
|
|
if ad_servers_ip or ad_clients_ip:
|
|
self.set_value('ad_filter_network', 'oui')
|
|
if ad_servers_ip:
|
|
ad_servers_netmask = self.get_old_value('ad_peer_netmask', 'ad_servers_netmask')
|
|
for ip, netmask in zip(ad_servers_ip, [nm[1] for nm in sorted(ad_servers_netmask.items())]):
|
|
self.append_value('ad_peer_ip', ip)
|
|
self.modify_last_value('ad_peer_netmask', netmask)
|
|
del(self.unknown_options['ad_servers_ip'])
|
|
del(self.unknown_options['ad_servers_netmask'])
|
|
if ad_clients_ip:
|
|
ad_clients_netmask = self.get_old_value('ad_peer_netmask', 'ad_clients_netmask')
|
|
for ip, netmask in zip(ad_clients_ip, [nm[1] for nm in sorted(ad_clients_netmask.items())]):
|
|
self.append_value('ad_peer_ip', ip)
|
|
self.modify_last_value('ad_peer_netmask', netmask)
|
|
del(self.unknown_options['ad_clients_ip'])
|
|
del(self.unknown_options['ad_clients_netmask'])
|
|
# Force SID
|
|
force_sid = self.get_value('ad_domain_sid')
|
|
if force_sid:
|
|
self.set_value('ad_force_domain_sid', 'oui')
|
|
# Squid modified variables : minutes -> seconds
|
|
for squidvar in ['forward_timeout', 'connect_timeout', 'read_timeout', 'request_timeout', 'persistent_request_timeout']:
|
|
squidval = self.get_value(squidvar)
|
|
if squidval is not None and not self.is_default(squidvar):
|
|
self.set_value(squidvar, squidval*60)
|
|
# Exim relay : force to "activate" when upgrade from Scribe 2.6.1 only
|
|
if self.var_exists('synchro_aaf'):
|
|
self.set_value('exim_relay', 'oui')
|
|
if self.get_value('activer_dhcp') == 'oui' and self.is_default('exim_relay_dhcp'):
|
|
self.set_value('exim_relay_dhcp', 'oui')
|
|
# Autosign certificat modified by user must be manual
|
|
if self.get_value('cert_type') == u'autosigné':
|
|
cert_is_modified = False
|
|
# set manuel to access to variable
|
|
self.set_value('cert_type', u'manuel')
|
|
for cert in ['server_cert', 'server_key', 'server_pem']:
|
|
if not self.is_default(cert):
|
|
cert_is_modified = True
|
|
break
|
|
if not cert_is_modified:
|
|
self.set_value('cert_type', u'autosigné')
|
|
# Store autosign certificat in manual type
|
|
if self.get_value('cert_type') == u'manuel':
|
|
for cert, filename in [('server_cert', u'/etc/ssl/certs/eole.crt'), ('server_pem', u'/etc/ssl/certs/eole.pem')]:
|
|
if self.is_default(cert):
|
|
self.set_value(cert, filename)
|
|
# gaspacho agent needs to pass by port 8080 has in 2.6.1 and ealier
|
|
if self.var_exists('gaspacho_https'):
|
|
self.set_value('gaspacho_https', 'non')
|
|
|
|
|
|
def upgrade2(major_version, old_release, current_release, config):
|
|
"""
|
|
major_version: version des scripts de migration (ex : 2.4)
|
|
old_release: version du config.eol à migrer (ex : 2.4.0)
|
|
current_release: version du serveur (ex : 2.5.1)
|
|
config: objet de configuration Tiramisu
|
|
"""
|
|
def _get_max_release():
|
|
"""
|
|
Calcul du dernier numéro de release disponible pour la version majeure
|
|
"""
|
|
ends = 0
|
|
for func in globals():
|
|
if func.startswith(func_start):
|
|
ends = max(ends, int(func.split('_')[-1]))
|
|
return ends
|
|
|
|
old_version = '.'.join(old_release.split('.')[0:2])
|
|
current_version = '.'.join(current_release.split('.')[0:2])
|
|
func_start = 'Upgrade_' + "_".join(major_version.split('.'))
|
|
if StrictVersion(current_version) == StrictVersion(old_version):
|
|
# upgrade au sein d'une même version
|
|
# ex : 2.5.1 -> 2.5.4 en 2.5
|
|
starts = int(old_release.split('.')[-1])
|
|
ends = int(current_release.split('.')[-1])
|
|
elif StrictVersion(major_version) == StrictVersion(old_version):
|
|
# upgrade "de base" vers une version supérieure
|
|
# ex : 2.4.2 -> 2.6.1 en 2.4
|
|
starts = int(old_release.split('.')[-1])
|
|
ends = _get_max_release()
|
|
elif StrictVersion(major_version) == StrictVersion(current_version):
|
|
# upgrade "final" vers une version supérieure
|
|
# ex : 2.4.2 -> 2.6.1 en 2.6
|
|
starts = -1
|
|
ends = int(current_release.split('.')[-1])
|
|
else:
|
|
# upgrade "intermédiaire" vers une version supérieure
|
|
# ex : 2.4.2 -> 2.6.1 en 2.5
|
|
starts = -1
|
|
ends = _get_max_release()
|
|
|
|
for i in xrange(starts + 1, ends + 1):
|
|
func = func_start + '_' + str(i)
|
|
if func in globals():
|
|
upgrade = globals()[func](config)
|
|
upgrade.run()
|