1007 lines
37 KiB
Python
1007 lines
37 KiB
Python
|
# -*- coding: utf-8 -*-
|
||
|
|
|
||
|
|
"""Apply configuration of EOLE servers.
|
||
|
|
|
||
|
|
"""
|
||
|
|
|
||
|
|
import os
|
||
|
|
import argparse
|
||
|
|
import time
|
||
|
|
import shutil
|
||
|
|
|
||
|
|
from glob import glob
|
||
|
|
|
||
|
|
import spwd
|
||
|
|
import getpass
|
||
|
|
from itertools import count
|
||
|
|
|
||
|
|
from pyeole.log import getLogger
|
||
|
|
from pyeole.log import init_logging
|
||
|
|
from pyeole.log import set_formatter
|
||
|
|
from pyeole.log import set_filters
|
||
|
|
|
||
|
|
from pyeole import scriptargs
|
||
|
|
from pyeole.lock import acquire, release
|
||
|
|
from pyeole import process
|
||
|
|
from pyeole.schedule import display_schedules, apply_schedules
|
||
|
|
from pyeole import ihm
|
||
|
|
from pyeole.pkg import report, EolePkg, _configure_sources_mirror, _MIRROR_DIST
|
||
|
|
from pyeole.pkg import PackageNotFoundError, RepositoryError, AptProxyError, AptCacherError
|
||
|
|
from pyeole.service import manage_service, unmanaged_service, manage_services, \
|
||
|
|
ServiceError
|
||
|
|
from pyeole.encode import normalize
|
||
|
|
from pyeole.diagnose.diagnose import MAJ_SUCCES_LOCK
|
||
|
|
|
||
|
|
from .error import FileNotFound, LockError, UnlockError
|
||
|
|
from .error import UserExit, UserExitError
|
||
|
|
from .error import VirtError
|
||
|
|
from .client import CreoleClient, CreoleClientError, NotFoundError
|
||
|
|
import fonctionseole, template, cert
|
||
|
|
from .eosfunc import is_instanciate
|
||
|
|
from .config import configeol, INSTANCE_LOCKFILE, UPGRADE_LOCKFILE, \
|
||
|
|
container_instance_lockfile, gen_conteneurs_needed, VIRTROOT, charset
|
||
|
|
from .containers import is_lxc_enabled, is_lxc_running, is_lxc_started, \
|
||
|
|
generate_lxc_container, create_mount_point, lxc_need_restart
|
||
|
|
from .error import NetworkConfigError
|
||
|
|
|
||
|
|
from pyeole.i18n import i18n
|
||
|
|
_ = i18n('creole')
|
||
|
|
|
||
|
|
try:
|
||
|
|
from zephir.lib_zephir import lock, unlock
|
||
|
|
zephir_libs = True
|
||
|
|
except Exception:
|
||
|
|
zephir_libs = False
|
||
|
|
|
||
|
|
client = CreoleClient()
|
||
|
|
|
||
|
|
global PKGMGR
|
||
|
|
PKGMGR = None
|
||
|
|
|
||
|
|
error_msg_documentation = _(u"""For more informations, read section
|
||
|
|
'Mise en œuvre des modules EOLE' in module documentation or
|
||
|
|
common documentation.""")
|
||
|
|
def load_pkgmgr():
|
||
|
|
global PKGMGR
|
||
|
|
if PKGMGR is None:
|
||
|
|
cache()
|
||
|
|
PKGMGR = EolePkg('apt', container_mode=CACHE['is_lxc_enabled'])
|
||
|
|
PKGMGR.pkgmgr.groups = CACHE
|
||
|
|
PKGMGR.pkgmgr._load_apt_cache()
|
||
|
|
eoles = []
|
||
|
|
for eole in client.get_creole(u'serveur_maj'):
|
||
|
|
eoles.append('http://{0}/eole/'.format(eole))
|
||
|
|
ubuntus = []
|
||
|
|
for ubuntu in client.get_creole(u'ubuntu_update_mirrors'):
|
||
|
|
ubuntus.append('http://{0}/ubuntu/'.format(ubuntu))
|
||
|
|
envoles = []
|
||
|
|
try:
|
||
|
|
for envole in client.get_creole(u'envole_update_mirrors'):
|
||
|
|
envoles.append('http://{0}/envole/'.format(envole))
|
||
|
|
except NotFoundError:
|
||
|
|
pass
|
||
|
|
for cache_ in PKGMGR.pkgmgr.cache._list.list:
|
||
|
|
if cache_.uri in eoles:
|
||
|
|
PKGMGR.pkgmgr._test_mirror(cache_.uri, _MIRROR_DIST['EOLE'])
|
||
|
|
eoles = []
|
||
|
|
if cache_.uri in ubuntus:
|
||
|
|
PKGMGR.pkgmgr._test_mirror(cache_.uri, _MIRROR_DIST['Ubuntu'])
|
||
|
|
ubuntus = []
|
||
|
|
if cache_.uri in envoles:
|
||
|
|
PKGMGR.pkgmgr._test_mirror(cache_.uri, _MIRROR_DIST['Envole'])
|
||
|
|
envoles = []
|
||
|
|
fonctionseole.PkgManager = PKGMGR
|
||
|
|
|
||
|
|
_LOGFILENAME = '/var/log/reconfigure.log'
|
||
|
|
|
||
|
|
# Command line options
|
||
|
|
class Option:
|
||
|
|
"""Manage commande line options with defaults
|
||
|
|
|
||
|
|
"""
|
||
|
|
def __init__(self):
|
||
|
|
self.parser = argparse.ArgumentParser(
|
||
|
|
description=_(u"Applying EOLE configuration."),
|
||
|
|
parents=[scriptargs.container(),
|
||
|
|
scriptargs.logging(level='info')])
|
||
|
|
self.parser.add_argument('-i', '--interactive', action='store_true',
|
||
|
|
help=_(u"leave process in interactive mode"))
|
||
|
|
self.parser.add_argument('-f', '--force', action='store_true',
|
||
|
|
help=_(u"override Zéphir lock"))
|
||
|
|
self.parser.add_argument('-a', '--auto', action='store_true',
|
||
|
|
help=_(u"automatic reboot if necessary"))
|
||
|
|
self.__opts = self.parser.parse_args([])
|
||
|
|
|
||
|
|
def update_from_cmdline(self, force_args=None, force_options=None):
|
||
|
|
"""Parse command line
|
||
|
|
"""
|
||
|
|
self.__opts = self.parser.parse_args(force_args)
|
||
|
|
if self.__opts.verbose:
|
||
|
|
self.__opts.log_level = 'info'
|
||
|
|
if self.__opts.debug:
|
||
|
|
self.__opts.log_level = 'debug'
|
||
|
|
if force_options is not None:
|
||
|
|
for key, value in force_options.items():
|
||
|
|
setattr(self.__opts, key, value)
|
||
|
|
self.__dict__.update(self.__opts.__dict__)
|
||
|
|
|
||
|
|
def __getattr__(self, name):
|
||
|
|
if name in ['__opts', 'update_from_cmdline']:
|
||
|
|
return self.__dict__[name]
|
||
|
|
else:
|
||
|
|
return getattr(self.__opts, name)
|
||
|
|
|
||
|
|
options = Option()
|
||
|
|
|
||
|
|
# To use log from every functions
|
||
|
|
log = getLogger(__name__)
|
||
|
|
|
||
|
|
# Same name for instance and reconfigure
|
||
|
|
LOCK_NAME = u'reconfigure'
|
||
|
|
|
||
|
|
# Run scripts in directories
|
||
|
|
RUNPARTS_PATH = u'/usr/share/eole'
|
||
|
|
RUNPARTS_CMD = u'/bin/run-parts --exit-on-error -v {directory} --arg {compat} 2>&1'
|
||
|
|
|
||
|
|
# Compatibility
|
||
|
|
COMPAT_NAME = u'reconfigure'
|
||
|
|
|
||
|
|
#def parse_cmdline():
|
||
|
|
# """Parse command line
|
||
|
|
# """
|
||
|
|
# descr = u"Application de la configuration EOLE"
|
||
|
|
# parser = argparse.ArgumentParser(description=descr,
|
||
|
|
# parents=[scriptargs.container(),
|
||
|
|
# scriptargs.logging(level='info')])
|
||
|
|
# parser.add_argument('-i', '--interactive', action='store_true',
|
||
|
|
# help=u"lancer le processus en mode interactif")
|
||
|
|
# parser.add_argument('-f', '--force', action='store_true',
|
||
|
|
# help=u"force l'action même s'il existe des verrous")
|
||
|
|
# parser.add_argument('-a', '--auto', action='store_true',
|
||
|
|
# help=u"redémarrage automatique si nécessaire")
|
||
|
|
#
|
||
|
|
# opts = parser.parse_args()
|
||
|
|
# if opts.verbose:
|
||
|
|
# opts.log_level = 'info'
|
||
|
|
# if opts.debug:
|
||
|
|
# opts.log_level = 'debug'
|
||
|
|
# return opts
|
||
|
|
|
||
|
|
def copyDirectoryContent(src, dst):
|
||
|
|
for fic in os.listdir(src):
|
||
|
|
# Skip links or we ovewrite existing certificates
|
||
|
|
if os.path.islink(os.path.join(src, fic)):
|
||
|
|
continue
|
||
|
|
try:
|
||
|
|
shutil.copy2(os.path.join(src, fic), dst)
|
||
|
|
except shutil.Error, err:
|
||
|
|
# ignore if files already exists
|
||
|
|
pass
|
||
|
|
|
||
|
|
def user_exit(*args, **kwargs):
|
||
|
|
"""
|
||
|
|
sortie utilisateur "propre"
|
||
|
|
"""
|
||
|
|
log.warn(_(u'! Abandoning configuration !'))
|
||
|
|
log.warn(_(u'System may be in an incoherent state.\n\n'))
|
||
|
|
raise UserExitError()
|
||
|
|
|
||
|
|
def unlock_actions(need_lock=True):
|
||
|
|
if zephir_libs:
|
||
|
|
#FIXME: lock de Zephir !
|
||
|
|
unlock('actions')
|
||
|
|
try:
|
||
|
|
release(LOCK_NAME, level='system')
|
||
|
|
except Exception, err:
|
||
|
|
# FIXME: move lock exception to pyeole.lock #7400
|
||
|
|
if need_lock:
|
||
|
|
raise UnlockError(str(err))
|
||
|
|
|
||
|
|
def lock_actions():
|
||
|
|
try:
|
||
|
|
acquire(LOCK_NAME, level="system")
|
||
|
|
except Exception, err:
|
||
|
|
# FIXME: move lock exception to pyeole.lock #7400
|
||
|
|
raise LockError(str(err))
|
||
|
|
if zephir_libs:
|
||
|
|
#FIXME: lock de Zephir !
|
||
|
|
lock('actions')
|
||
|
|
|
||
|
|
def reset_compat_name():
|
||
|
|
"""
|
||
|
|
Réinitialise le nom de la procédure en cours
|
||
|
|
en fonction de l'environnement
|
||
|
|
"""
|
||
|
|
global COMPAT_NAME
|
||
|
|
if options.interactive:
|
||
|
|
COMPAT_NAME = u'instance'
|
||
|
|
else:
|
||
|
|
COMPAT_NAME = u'reconfigure'
|
||
|
|
|
||
|
|
def run_parts(directory):
|
||
|
|
"""Run scripts in a directory
|
||
|
|
|
||
|
|
@param directory: name of a directory
|
||
|
|
@type directory: C{str}
|
||
|
|
"""
|
||
|
|
dirpath = os.path.join(RUNPARTS_PATH, directory)
|
||
|
|
if os.path.isdir(dirpath):
|
||
|
|
ihm.print_title(_(u'Running scripts {0}').format(directory))
|
||
|
|
code = os.system(RUNPARTS_CMD.format(directory=dirpath, compat=COMPAT_NAME))
|
||
|
|
if code != 0:
|
||
|
|
raise Exception(_(u'Error {0}').format(directory))
|
||
|
|
|
||
|
|
def restart_creoled():
|
||
|
|
"""
|
||
|
|
Restart creoled service and verify if the client is OK
|
||
|
|
"""
|
||
|
|
unmanaged_service(u'restart', u'creoled', u'service', display='console')
|
||
|
|
try:
|
||
|
|
client.get_creole(u'eole_version')
|
||
|
|
except CreoleClientError:
|
||
|
|
msg = _(u"Please check creoled's log (/var/log/rsyslog/local/creoled/creoled.info.log)\nand restart service with command 'service creoled start'")
|
||
|
|
raise CreoleClientError(msg)
|
||
|
|
|
||
|
|
def prepare(need_lock=True):
|
||
|
|
"""Sanity checks.
|
||
|
|
|
||
|
|
"""
|
||
|
|
global RUNPARTS_CMD
|
||
|
|
# Clean exit
|
||
|
|
if need_lock:
|
||
|
|
ihm.catch_signal(user_exit)
|
||
|
|
lock_actions()
|
||
|
|
|
||
|
|
if options.container != None:
|
||
|
|
RUNPARTS_CMD += u" --regex '^[09][09]-{0}$'".format(options.container)
|
||
|
|
|
||
|
|
ihm.print_title(_(u"Preparation for {0}").format(COMPAT_NAME))
|
||
|
|
|
||
|
|
if not os.path.isfile(configeol):
|
||
|
|
print _(u"Server is not configured.")
|
||
|
|
print
|
||
|
|
print error_msg_documentation
|
||
|
|
print
|
||
|
|
raise FileNotFound(_(u'Missing file {0}.').format(configeol))
|
||
|
|
|
||
|
|
display_info = False
|
||
|
|
|
||
|
|
if not options.interactive and (is_instanciate() == 'non' or os.path.isfile(UPGRADE_LOCKFILE)):
|
||
|
|
ihm.print_red(_(u"Server must be instantiated before any reconfiguration can occur."))
|
||
|
|
display_info = True
|
||
|
|
|
||
|
|
if options.interactive and is_instanciate() == 'oui' and \
|
||
|
|
not os.path.isfile(UPGRADE_LOCKFILE) and \
|
||
|
|
not os.path.isfile(container_instance_lockfile):
|
||
|
|
ihm.print_red(_(u"Server already instantiated."))
|
||
|
|
print
|
||
|
|
print _(u"To modify configuration parameter (e.g. IP address), use:")
|
||
|
|
print _(u"'gen_config'")
|
||
|
|
print _(u"then 'reconfigure' to apply changes.")
|
||
|
|
display_info = True
|
||
|
|
|
||
|
|
if os.path.isfile(container_instance_lockfile) and not options.interactive:
|
||
|
|
raise Exception(_('you have run gen_conteneurs, please use instance instead of reconfigure'))
|
||
|
|
|
||
|
|
if os.path.isfile(gen_conteneurs_needed):
|
||
|
|
raise Exception(_('You have to run gen_conteneurs before instance'))
|
||
|
|
|
||
|
|
if display_info:
|
||
|
|
print
|
||
|
|
print error_msg_documentation
|
||
|
|
print
|
||
|
|
if not options.interactive:
|
||
|
|
raise Exception(_(u"First instantiate server."))
|
||
|
|
else:
|
||
|
|
if ihm.prompt_boolean(_(u"Proceeding with instantiation ?"),
|
||
|
|
interactive=options.interactive,
|
||
|
|
default=False) is False:
|
||
|
|
raise UserExit()
|
||
|
|
else:
|
||
|
|
fonctionseole.zephir("MSG", "Instance forcée par l'utilisateur",
|
||
|
|
COMPAT_NAME.upper())
|
||
|
|
|
||
|
|
# redémarrage du service creoled
|
||
|
|
restart_creoled()
|
||
|
|
|
||
|
|
if fonctionseole.init_proc(COMPAT_NAME.upper()) == False and not options.force:
|
||
|
|
log.warn(_(u"This process is blocked, contact Zéphir administrator."))
|
||
|
|
if ihm.prompt_boolean(_(u"Force execution?"),
|
||
|
|
interactive=options.interactive,
|
||
|
|
default=False) is False:
|
||
|
|
if not options.interactive:
|
||
|
|
log.warn(_(u"Use -f option if you want to force execution"))
|
||
|
|
raise UserExitError()
|
||
|
|
else:
|
||
|
|
fonctionseole.zephir("MSG",
|
||
|
|
"Instance forcée par l'utilisateur",
|
||
|
|
COMPAT_NAME.upper())
|
||
|
|
|
||
|
|
|
||
|
|
def valid_mandatory(need_lock):
|
||
|
|
try:
|
||
|
|
client.valid_mandatory()
|
||
|
|
except Exception, err:
|
||
|
|
log.warn(_('Configuration validation problem, please check server configuration.'))
|
||
|
|
print
|
||
|
|
print error_msg_documentation
|
||
|
|
print
|
||
|
|
unlock_actions(need_lock)
|
||
|
|
raise ValueError(str(err))
|
||
|
|
|
||
|
|
def _start_containers():
|
||
|
|
""" Try to start containers and make sure they are started
|
||
|
|
"""
|
||
|
|
cache()
|
||
|
|
for group_name in CACHE['groups_container']:
|
||
|
|
group = CACHE['group_infos'][group_name]
|
||
|
|
create_mount_point(group)
|
||
|
|
|
||
|
|
if os.access('/usr/share/eole/preservice/00-lxc-net', os.X_OK):
|
||
|
|
log.debug("Override lxc-net systemd script")
|
||
|
|
process.system_code(['/usr/share/eole/preservice/00-lxc-net'])
|
||
|
|
|
||
|
|
unmanaged_service(u'start', u'lxc-net', u'systemd', display='console', ctx=CACHE['group_infos']['root'])
|
||
|
|
try:
|
||
|
|
unmanaged_service(u'status', u'lxc', u'systemd')
|
||
|
|
except ServiceError:
|
||
|
|
unmanaged_service(u'start', u'lxc', u'systemd', display='console', ctx=CACHE['group_infos']['root'])
|
||
|
|
#if lxc not started, do not wait for it
|
||
|
|
#(we already waiting for it in systemd service)
|
||
|
|
#if started, waiting for ssh access
|
||
|
|
|
||
|
|
max_try = 10
|
||
|
|
for count in range(max_try):
|
||
|
|
s_code, s_out, s_err = process.system_out(['lxc-ls', '--stopped'])
|
||
|
|
stopped = s_out.split()
|
||
|
|
f_code, f_out, f_err = process.system_out(['lxc-ls', '--frozen'])
|
||
|
|
frozen = f_out.split()
|
||
|
|
|
||
|
|
if stopped or frozen:
|
||
|
|
not_running = stopped + frozen
|
||
|
|
else:
|
||
|
|
# Everything is started by LXC
|
||
|
|
# Are they reachable by SSH?
|
||
|
|
not_running = []
|
||
|
|
for group_name in CACHE['groups_container']:
|
||
|
|
group_infos = CACHE['group_infos'][group_name]
|
||
|
|
if not is_lxc_running(group_infos):
|
||
|
|
not_running.append(group_name)
|
||
|
|
|
||
|
|
log.debug('Waiting 1 second for SSH access')
|
||
|
|
time.sleep(1)
|
||
|
|
|
||
|
|
if not not_running:
|
||
|
|
break
|
||
|
|
|
||
|
|
if stopped:
|
||
|
|
for cont in stopped:
|
||
|
|
log.debug('Manual start of stopped container “{0}”'.format(cont))
|
||
|
|
process.system_out(['lxc-start', '--name', cont, '--daemon',
|
||
|
|
'-o', '/var/log/lxc-{0}.log'.format(cont)])
|
||
|
|
|
||
|
|
if frozen:
|
||
|
|
for cont in frozen:
|
||
|
|
log.debug('Manual unfreeze of frozen container “{0}”'.format(cont))
|
||
|
|
process.system_out(['lxc-unfreeze', '--name', cont,
|
||
|
|
'-o', '/var/log/lxc-{0}.log'.format(cont)])
|
||
|
|
|
||
|
|
if not_running:
|
||
|
|
waiting_for = ', '.join(not_running)
|
||
|
|
msg = _(u'Unable to start LXC container : {0}',
|
||
|
|
u'Unable to start LXC containers : {0}', len(not_running))
|
||
|
|
raise VirtError(msg.format(waiting_for))
|
||
|
|
|
||
|
|
|
||
|
|
def containers(minimal=False, log_=None):
|
||
|
|
"""Generate containers
|
||
|
|
"""
|
||
|
|
if log_ is None:
|
||
|
|
log_ = log
|
||
|
|
VAR_LXC='/var/lib/lxc'
|
||
|
|
OPT_LXC='/opt/lxc'
|
||
|
|
|
||
|
|
cache()
|
||
|
|
if not CACHE['is_lxc_enabled']:
|
||
|
|
log.debug(_(u'Container mode is disabled.'))
|
||
|
|
return True
|
||
|
|
if not options.interactive:
|
||
|
|
for group in CACHE['groups_container']:
|
||
|
|
if not os.path.isdir(os.path.join(VIRTROOT, group)):
|
||
|
|
raise Exception(_(u'container {0} does not already exist, please use gen_conteneurs to create this container').format(group))
|
||
|
|
else:
|
||
|
|
# make /var/lib/lxc -> /opt/lxc
|
||
|
|
if os.path.isdir(VAR_LXC) and not os.path.exists(OPT_LXC):
|
||
|
|
ihm.print_title(_(u"Setting up {0}").format(OPT_LXC))
|
||
|
|
unmanaged_service(u'stop', u'lxc', u'systemd', display='console')
|
||
|
|
unmanaged_service(u'stop', u'lxc-net', u'systemd', display='console')
|
||
|
|
shutil.move(VAR_LXC, OPT_LXC)
|
||
|
|
os.symlink(OPT_LXC, VAR_LXC)
|
||
|
|
#first instance should be in minimal mode
|
||
|
|
minimal = True
|
||
|
|
|
||
|
|
ihm.print_title(_(u'Generating containers'))
|
||
|
|
|
||
|
|
engine = template.CreoleTemplateEngine()
|
||
|
|
rootctx = CACHE['group_infos']['root']
|
||
|
|
if minimal:
|
||
|
|
# inject var _minimal_mode in creole's vars that can be used in template
|
||
|
|
engine.creole_variables_dict['_minimal_mode'] = True
|
||
|
|
engine.instance_file(u'/etc/ssh/ssh_config', ctx=rootctx)
|
||
|
|
engine.instance_file(u'/etc/lxc/default.conf', ctx=rootctx)
|
||
|
|
engine.instance_file(u'/etc/dnsmasq.d/lxc', ctx=rootctx)
|
||
|
|
engine.instance_file(u'/etc/default/lxc-net', ctx=rootctx)
|
||
|
|
engine.instance_file(u'/etc/apt/apt.conf.d/02eoleproxy', ctx=rootctx)
|
||
|
|
if CACHE['module_instancie'] == 'oui':
|
||
|
|
engine.instance_file(u'/etc/resolv.conf', ctx=rootctx)
|
||
|
|
|
||
|
|
load_pkgmgr()
|
||
|
|
PKGMGR.pkgmgr._prepare_cache()
|
||
|
|
for group in CACHE['groups_container']:
|
||
|
|
generate_lxc_container(group)
|
||
|
|
groupctx = CACHE['group_infos'][group]
|
||
|
|
if minimal:
|
||
|
|
engine.instance_file(u'../fstab', container=group, ctx=groupctx)
|
||
|
|
engine.instance_file(u'../config', container=group, ctx=groupctx)
|
||
|
|
engine.instance_file(u'../devices.hook', container=group, ctx=groupctx)
|
||
|
|
engine.instance_file(u'/etc/network/interfaces', container=group, ctx=groupctx)
|
||
|
|
engine.instance_file(u'/etc/apt/apt.conf.d/02eoleproxy', container=group, ctx=groupctx)
|
||
|
|
engine.instance_file(u'/etc/ssh/sshd_config', container=group, ctx=groupctx)
|
||
|
|
if CACHE['module_instancie'] == 'oui':
|
||
|
|
container_path = os.path.join(groupctx['path'], 'etc/resolv.conf')
|
||
|
|
if os.path.islink(container_path):
|
||
|
|
os.remove(container_path)
|
||
|
|
engine.instance_file(u'/etc/resolv.conf', container=group, ctx=groupctx)
|
||
|
|
PKGMGR.pkgmgr._umount_cdrom()
|
||
|
|
|
||
|
|
ihm.print_title(_(u'Starting containers'))
|
||
|
|
_start_containers()
|
||
|
|
|
||
|
|
def remove_packages():
|
||
|
|
""" Remove packages listed in /usr/share/eole/remove.d/ files
|
||
|
|
param: repo: EoleApt Object
|
||
|
|
"""
|
||
|
|
torm_conf = glob(u'/usr/share/eole/remove.d/*.conf')
|
||
|
|
pkg_list = []
|
||
|
|
for config in torm_conf:
|
||
|
|
try:
|
||
|
|
f_h = open(config, 'r')
|
||
|
|
for line in f_h.readlines():
|
||
|
|
pkg_list.append(line.strip('\n'))
|
||
|
|
f_h.close()
|
||
|
|
except IOError, err:
|
||
|
|
log.error(_(u'Can not read file {0}: {1}').format(config, err))
|
||
|
|
|
||
|
|
try:
|
||
|
|
load_pkgmgr()
|
||
|
|
except (RepositoryError, AptProxyError, AptCacherError), err:
|
||
|
|
pass
|
||
|
|
|
||
|
|
kernels = fonctionseole.get_kernel_to_remove()
|
||
|
|
|
||
|
|
if kernels:
|
||
|
|
ihm.print_line(_(u"Removing old linux kernels and associate headers."))
|
||
|
|
pkg_list.extend(kernels)
|
||
|
|
|
||
|
|
if pkg_list != []:
|
||
|
|
try:
|
||
|
|
PKGMGR.remove(packages=pkg_list)
|
||
|
|
except (PackageNotFoundError, SystemError), err:
|
||
|
|
msg = _(u'Unable to remove some packages: {0}')
|
||
|
|
log.warn(msg.format(err))
|
||
|
|
log.warn(_(u"These packages will be removed next 'reconfigure'"))
|
||
|
|
|
||
|
|
|
||
|
|
CACHE = {}
|
||
|
|
def cache():
|
||
|
|
global CACHE
|
||
|
|
if not 'groups' in CACHE:
|
||
|
|
CACHE['groups'] = client.get_groups()
|
||
|
|
CACHE['groups_container'] = []
|
||
|
|
for group in CACHE['groups']:
|
||
|
|
if group not in ['root', 'all']:
|
||
|
|
CACHE['groups_container'].append(group)
|
||
|
|
CACHE['group_infos'] = {}
|
||
|
|
for group_name in CACHE['groups']:
|
||
|
|
group_infos = client.get_group_infos(group_name)
|
||
|
|
CACHE['group_infos'][group_name] = group_infos
|
||
|
|
CACHE['is_lxc_enabled'] = is_lxc_enabled()
|
||
|
|
CACHE['module_instancie'] = client.get_creole('module_instancie')
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
def install_packages(silent=False):
|
||
|
|
"""Install package for each container group
|
||
|
|
"""
|
||
|
|
load_pkgmgr()
|
||
|
|
|
||
|
|
cache()
|
||
|
|
header = _(u'Checking Packages for container')
|
||
|
|
for group_name, group_infos in CACHE['group_infos'].items():
|
||
|
|
package_names = [pkg[u'name'] for pkg in group_infos[u'packages']]
|
||
|
|
if package_names != []:
|
||
|
|
msg = header + ' {0}: {1}'.format(group_name, ' '.join(package_names))
|
||
|
|
ihm.print_line(msg)
|
||
|
|
PKGMGR.install(packages=package_names,
|
||
|
|
silent=silent,
|
||
|
|
container=group_infos[u'name'])
|
||
|
|
|
||
|
|
|
||
|
|
def packages():
|
||
|
|
"""Manage packages
|
||
|
|
"""
|
||
|
|
ihm.print_title(_(u'Managing packages'))
|
||
|
|
log.info(_(u' Removing packages'))
|
||
|
|
ihm.print_line(_(u'Removing packages'))
|
||
|
|
remove_packages()
|
||
|
|
log.info(_(u' Installing packages'))
|
||
|
|
ihm.print_line(_(u'Installing packages'))
|
||
|
|
install_packages()
|
||
|
|
|
||
|
|
|
||
|
|
def templates():
|
||
|
|
"""Run pretemplate scripts and manage templates
|
||
|
|
"""
|
||
|
|
ihm.print_title(_(u'Generating configuration files'))
|
||
|
|
log.info(_(u'Generating configuration files'))
|
||
|
|
cache()
|
||
|
|
try:
|
||
|
|
tmpl = template.CreoleTemplateEngine()
|
||
|
|
tmpl.instance_files(container=options.container, containers_ctx=CACHE['group_infos'].values())
|
||
|
|
except Exception, err:
|
||
|
|
if options.debug:
|
||
|
|
log.debug(err, exc_info=True)
|
||
|
|
else:
|
||
|
|
log.error(err)
|
||
|
|
raise err
|
||
|
|
|
||
|
|
|
||
|
|
def services(action, display_title=True, try_restart_lxc=True):
|
||
|
|
"""Manage services
|
||
|
|
"""
|
||
|
|
cache()
|
||
|
|
exclude = None
|
||
|
|
if action == u'stop':
|
||
|
|
if display_title:
|
||
|
|
ihm.print_title(_(u"Stopping services"))
|
||
|
|
exclude = (('root', 'networking'),)
|
||
|
|
elif action == u'start':
|
||
|
|
if display_title:
|
||
|
|
ihm.print_title(_(u"Starting services"))
|
||
|
|
# ne pas demarrer le service certbot, c'est un service oneshot
|
||
|
|
# et pyeole.service n'a pas l'air d'aimer ... #22092
|
||
|
|
exclude = (('root', 'networking'), ('root', 'certbot'))
|
||
|
|
ctx = CACHE['group_infos']['root']
|
||
|
|
manage_services(action, u'networking', display='console', containers_ctx=[ctx])
|
||
|
|
if try_restart_lxc and CACHE['is_lxc_enabled']:
|
||
|
|
if lxc_need_restart():
|
||
|
|
unmanaged_service(u'stop', u'lxc', u'systemd', display='console', ctx=ctx)
|
||
|
|
unmanaged_service(u'stop', u'lxc-net', u'systemd', display='console', ctx=ctx)
|
||
|
|
_start_containers()
|
||
|
|
elif action == u'configure':
|
||
|
|
if display_title:
|
||
|
|
ihm.print_title(_(u"Configuring services"))
|
||
|
|
else:
|
||
|
|
raise ValueError(_(u"Unknown service action: {0}").format(action))
|
||
|
|
if options.container is not None:
|
||
|
|
containers_ctx = [CACHE['group_infos'][options.containers]]
|
||
|
|
else:
|
||
|
|
containers_ctx = CACHE['group_infos'].values()
|
||
|
|
manage_services(action, container=options.container, display='console', exclude=exclude, containers_ctx=containers_ctx)
|
||
|
|
|
||
|
|
|
||
|
|
def _gen_user_list():
|
||
|
|
"""Generate list of users for password modification
|
||
|
|
|
||
|
|
Start with basic one and ask for supplementary users.
|
||
|
|
"""
|
||
|
|
yield 'root'
|
||
|
|
|
||
|
|
node = client.get_creole(u'activer_onenode', 'non')
|
||
|
|
master = client.get_creole(u'activer_onesinglenode', 'non')
|
||
|
|
if node == 'oui' and master == 'non':
|
||
|
|
yield 'oneadmin'
|
||
|
|
|
||
|
|
for number in count(1):
|
||
|
|
if number == 1:
|
||
|
|
yield 'eole'
|
||
|
|
else:
|
||
|
|
yield 'eole{0}'.format(number)
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
def users():
|
||
|
|
"""Manage users
|
||
|
|
"""
|
||
|
|
from passlib.context import CryptContext
|
||
|
|
ihm.print_title(_(u'Managing system user accounts'))
|
||
|
|
schemes = [u'sha512_crypt', u'sha256_crypt', u'sha1_crypt', u'md5_crypt']
|
||
|
|
cryptctx = CryptContext(schemes=schemes)
|
||
|
|
default_pass = {u'root': u'$eole&123456$',
|
||
|
|
u'eole': u'$fpmf&123456$',
|
||
|
|
u'oneadmin': u'$eole&123456$'}
|
||
|
|
|
||
|
|
if not options.interactive:
|
||
|
|
log.debug(_(u'No system user account management in non-interactive mode.'))
|
||
|
|
return
|
||
|
|
|
||
|
|
for user in _gen_user_list():
|
||
|
|
try:
|
||
|
|
user_infos = spwd.getspnam(user)
|
||
|
|
except KeyError:
|
||
|
|
if user == u'root':
|
||
|
|
msg = _(u"'root' user unknown. This is abnormal.")
|
||
|
|
raise Exception(msg)
|
||
|
|
|
||
|
|
# no new administrator with NFS (#16321)
|
||
|
|
if user != 'eole' and client.get_creole(u'adresse_serveur_nfs', None) is not None:
|
||
|
|
log.warn(_(u'No new EOLE account with /home on NFS'))
|
||
|
|
break
|
||
|
|
|
||
|
|
prompt = _('Create new administrator user account {0}?')
|
||
|
|
if user != 'eole' and ihm.prompt_boolean(prompt.format(user)) is False:
|
||
|
|
break
|
||
|
|
|
||
|
|
msg = _(u"Creating unexistent user {0}")
|
||
|
|
log.info(msg.format(user))
|
||
|
|
|
||
|
|
cmd = ['adduser', '--quiet', '--shell', '/usr/bin/manage-eole',
|
||
|
|
'--gecos', '{0} user'.format(user.upper()),
|
||
|
|
'--disabled-password', user]
|
||
|
|
code = process.system_code(cmd)
|
||
|
|
if code != 0:
|
||
|
|
msg = _(u"Unable to create user {0}")
|
||
|
|
raise Exception(msg.format(user))
|
||
|
|
|
||
|
|
cmd = ['usermod', '--append', '--groups', 'adm,mail', user]
|
||
|
|
code, out, err = process.system_out(cmd)
|
||
|
|
if code != 0:
|
||
|
|
msg = _(u"Unable to add '{0}' to group 'adm'.")
|
||
|
|
raise Exception(msg.format(user))
|
||
|
|
|
||
|
|
# Update informations
|
||
|
|
user_infos = spwd.getspnam(user)
|
||
|
|
|
||
|
|
if user not in default_pass and user_infos.sp_pwd not in ['!', '*']:
|
||
|
|
msg = _(u"No modification of password of administrator user account {0}.")
|
||
|
|
log.warn(msg.format(user))
|
||
|
|
continue
|
||
|
|
|
||
|
|
# Change password:
|
||
|
|
# - on first instance
|
||
|
|
# - if user is not an EOLE default user
|
||
|
|
# - if user password match default ones
|
||
|
|
if (not os.path.isfile(INSTANCE_LOCKFILE)
|
||
|
|
or (user not in default_pass or user_infos.sp_pwd in ['!', '*']
|
||
|
|
or cryptctx.verify(default_pass[user], user_infos.sp_pwd))):
|
||
|
|
|
||
|
|
msg = _(u"# Modificating password for user account {0} #")
|
||
|
|
msg = msg.format(user)
|
||
|
|
log.warn(u'#' * len(msg))
|
||
|
|
log.warn(msg)
|
||
|
|
log.warn(u'#' * len(msg))
|
||
|
|
max_try = 5
|
||
|
|
prompt = u'{0}{1}: '
|
||
|
|
first_prompt = _(u"New password")
|
||
|
|
second_prompt = _(u"Confirming new password")
|
||
|
|
loop_counter = u''
|
||
|
|
for attempt in range(1, max_try+2):
|
||
|
|
if attempt == max_try+1:
|
||
|
|
msg = _(u"Password input errors for {0}. Abandon.")
|
||
|
|
raise Exception(msg.format(user))
|
||
|
|
|
||
|
|
loop_counter = loop_counter.format(attempt, max_try)
|
||
|
|
passwd = getpass.getpass(prompt.format(first_prompt,
|
||
|
|
loop_counter))
|
||
|
|
confirm_pass = getpass.getpass(prompt.format(second_prompt,
|
||
|
|
loop_counter))
|
||
|
|
if passwd == confirm_pass:
|
||
|
|
if user in default_pass and default_pass[user] == passwd:
|
||
|
|
log.error(_(u"Can not use default password."))
|
||
|
|
else:
|
||
|
|
# Now we have the password
|
||
|
|
stdin = '{0}:{1}'.format(user, passwd)
|
||
|
|
code, stdout, stderr = process.system_out(['chpasswd'],
|
||
|
|
stdin=stdin)
|
||
|
|
if code == 0:
|
||
|
|
msg = _(u'User {0} password updated.')
|
||
|
|
log.info(msg.format(user))
|
||
|
|
# Success
|
||
|
|
break
|
||
|
|
msg = _(u"Error changing password for {0}.")
|
||
|
|
try_again_pos = stdout.find('Try again.')
|
||
|
|
chpassmsg = stdout[0:try_again_pos]
|
||
|
|
log.error(msg.format(user))
|
||
|
|
print chpassmsg
|
||
|
|
else:
|
||
|
|
log.error(_(u"Passwords mismatch."))
|
||
|
|
|
||
|
|
# Display counter
|
||
|
|
loop_counter = u' ({0}/{1})'
|
||
|
|
|
||
|
|
|
||
|
|
def certificates():
|
||
|
|
"""Manage certificates
|
||
|
|
|
||
|
|
"""
|
||
|
|
ihm.print_title(_(u'Managing certificates'))
|
||
|
|
try:
|
||
|
|
# regénération des hashes des certificats SSL après avec créé les nouveaux certificats
|
||
|
|
# porté de 2.3 #8488
|
||
|
|
cert.rehash_if_needed()
|
||
|
|
cert.gen_certs()
|
||
|
|
except Exception, err:
|
||
|
|
if options.debug:
|
||
|
|
log.debug(err, exc_info=True)
|
||
|
|
else:
|
||
|
|
log.error(err)
|
||
|
|
raise Exception(_(u"Error while generating certificates: {0}").format(err))
|
||
|
|
cache()
|
||
|
|
if CACHE['is_lxc_enabled']:
|
||
|
|
src = os.path.join(cert.ssl_dir, "certs")
|
||
|
|
for group_name in CACHE['groups_container']:
|
||
|
|
group = CACHE['group_infos'][group_name]
|
||
|
|
ihm.print_line(_("Copying certificates in {0}").format(group['name']))
|
||
|
|
dst = os.path.join('/', group['path'].lstrip('/').encode(charset), src.lstrip('/'))
|
||
|
|
copyDirectoryContent(src, dst)
|
||
|
|
process.system_out(['/usr/bin/c_rehash'], container=group_name)
|
||
|
|
|
||
|
|
|
||
|
|
def param_kernel():
|
||
|
|
"""Manage kernel parameters
|
||
|
|
"""
|
||
|
|
ihm.print_title(_(u'Applying kernel parameters'))
|
||
|
|
os.system('/sbin/sysctl -p >/dev/null')
|
||
|
|
|
||
|
|
def kill_dhclient():
|
||
|
|
"""Kill dhclient for static IP configuration.
|
||
|
|
|
||
|
|
"""
|
||
|
|
if client.get_creole(u'eth0_method') == u'statique':
|
||
|
|
os.system('killall dhclient dhclient3 2>/dev/null')
|
||
|
|
|
||
|
|
def finalize(need_lock=True):
|
||
|
|
"""Clean up
|
||
|
|
"""
|
||
|
|
ihm.print_title(_(u'Finalizing configuration'))
|
||
|
|
# enregistrement
|
||
|
|
try:
|
||
|
|
process.system_out("/usr/share/creole/diag.py")
|
||
|
|
except Exception:
|
||
|
|
pass
|
||
|
|
fonctionseole.zephir("FIN", "Configuration terminée", COMPAT_NAME.upper())
|
||
|
|
if not os.path.isfile(INSTANCE_LOCKFILE):
|
||
|
|
# l'instance est allée à son terme (#7051)
|
||
|
|
file(INSTANCE_LOCKFILE, 'w').close()
|
||
|
|
|
||
|
|
if os.path.isfile(UPGRADE_LOCKFILE):
|
||
|
|
os.unlink(UPGRADE_LOCKFILE)
|
||
|
|
|
||
|
|
if os.path.isfile(container_instance_lockfile):
|
||
|
|
os.unlink(container_instance_lockfile)
|
||
|
|
|
||
|
|
# sauvegarde des 2 dernières versions de la configuration (#8455)
|
||
|
|
old = '{0}.bak'.format(configeol)
|
||
|
|
old1 = '{0}.bak.1'.format(configeol)
|
||
|
|
if not os.path.isfile(old):
|
||
|
|
log.debug(_(u'Backup {0} in {1}'.format(configeol, old)))
|
||
|
|
shutil.copy(configeol, old)
|
||
|
|
elif process.system_out(['diff', '-q', configeol, old])[0] == 0:
|
||
|
|
log.debug(_(u"{0} was not modified".format(configeol)))
|
||
|
|
else:
|
||
|
|
log.debug(_(u'Backup {0} in {1}'.format(old, old1)))
|
||
|
|
shutil.copy(old, old1)
|
||
|
|
log.debug(_(u'Backup {0} in {1}'.format(configeol, old)))
|
||
|
|
shutil.copy(configeol, old)
|
||
|
|
if need_lock:
|
||
|
|
unlock_actions()
|
||
|
|
|
||
|
|
def update_server():
|
||
|
|
"""Manage server update
|
||
|
|
"""
|
||
|
|
if os.path.isfile(MAJ_SUCCES_LOCK):
|
||
|
|
os.remove(MAJ_SUCCES_LOCK)
|
||
|
|
if options.interactive:
|
||
|
|
log.info(_(u'Managing update'))
|
||
|
|
|
||
|
|
ihm.print_title(_(u'Updating server'))
|
||
|
|
if ihm.prompt_boolean(_(u"""An update is recommended.
|
||
|
|
Do you want to proceed with network update now ?"""),
|
||
|
|
default=True, level='warn',
|
||
|
|
default_uninteractive=False) is True:
|
||
|
|
report(2)
|
||
|
|
try:
|
||
|
|
load_pkgmgr()
|
||
|
|
_configure_sources_mirror(PKGMGR.pkgmgr)
|
||
|
|
PKGMGR.update(silent=True)
|
||
|
|
upgrades = PKGMGR.get_upgradable_list(silent=True)
|
||
|
|
require_dist_upgrade = False
|
||
|
|
for container, upgrades in upgrades.items():
|
||
|
|
if upgrades:
|
||
|
|
require_dist_upgrade = True
|
||
|
|
break
|
||
|
|
if require_dist_upgrade:
|
||
|
|
# At least one container require upgrade
|
||
|
|
PKGMGR.dist_upgrade()
|
||
|
|
# Update lock => OK, will be deleted at next reconfigure
|
||
|
|
report(0)
|
||
|
|
# recall reconfigure
|
||
|
|
main(force_options={'interactive': False})
|
||
|
|
# back to instance
|
||
|
|
options.interactive = True
|
||
|
|
reset_compat_name()
|
||
|
|
else:
|
||
|
|
log.warn(_(u"No updates available."))
|
||
|
|
report(3)
|
||
|
|
except Exception, err:
|
||
|
|
report(1, normalize(err))
|
||
|
|
raise err
|
||
|
|
|
||
|
|
|
||
|
|
def schedule():
|
||
|
|
"""Manage task scheduling
|
||
|
|
"""
|
||
|
|
ihm.print_title(_(u'Task scheduling'))
|
||
|
|
apply_schedules()
|
||
|
|
display_schedules()
|
||
|
|
# 1er lancement de instance
|
||
|
|
#if not os.path.isfile(schedule.SCHEDULE_FILE):
|
||
|
|
# schedule.add_post_schedule('majauto', 'weekly')
|
||
|
|
#schedule.prog_schedule()
|
||
|
|
|
||
|
|
def is_valid_ip_eth0():
|
||
|
|
"""Check if adresse_ip_eth0 is 169.254.0.1
|
||
|
|
"""
|
||
|
|
ip_eth0 = client.get_creole(u'adresse_ip_eth0')
|
||
|
|
if ip_eth0 == "169.254.0.1":
|
||
|
|
return False
|
||
|
|
else:
|
||
|
|
return True
|
||
|
|
|
||
|
|
|
||
|
|
def reboot_server():
|
||
|
|
"""Reboot the server if required
|
||
|
|
"""
|
||
|
|
if fonctionseole.controle_kernel():
|
||
|
|
if options.interactive:
|
||
|
|
print
|
||
|
|
if ihm.prompt_boolean(_(u"""Reboot is necessary.
|
||
|
|
Do you want to reboot now?"""),
|
||
|
|
default=True, level='warn') is True:
|
||
|
|
fonctionseole.zephir("MSG",
|
||
|
|
"Demande de redémarrage acceptée par l'utilisateur",
|
||
|
|
COMPAT_NAME.upper())
|
||
|
|
process.system_code(['reboot'])
|
||
|
|
else:
|
||
|
|
fonctionseole.zephir("MSG",
|
||
|
|
"Demande de redémarrage refusée par l'utilisateur",
|
||
|
|
COMPAT_NAME.upper())
|
||
|
|
else:
|
||
|
|
print
|
||
|
|
ihm.print_orange(_(u'Reboot necessary'))
|
||
|
|
time.sleep(1)
|
||
|
|
print
|
||
|
|
if options.auto:
|
||
|
|
fonctionseole.zephir("MSG", "Redémarrage automatique",
|
||
|
|
COMPAT_NAME.upper())
|
||
|
|
process.system_code(['reboot'])
|
||
|
|
else:
|
||
|
|
fonctionseole.zephir("MSG", "Redémarrage du serveur à planifier",
|
||
|
|
COMPAT_NAME.upper())
|
||
|
|
|
||
|
|
|
||
|
|
def main(force_options=None, force_args=None, need_lock=True):
|
||
|
|
"""Entry point
|
||
|
|
"""
|
||
|
|
global log
|
||
|
|
options.update_from_cmdline(force_args=force_args,
|
||
|
|
force_options=force_options)
|
||
|
|
|
||
|
|
try:
|
||
|
|
# module level logger
|
||
|
|
log = init_logging(name=u'reconfigure', level=options.log_level,
|
||
|
|
console=['stderr', 'stddebug'],
|
||
|
|
filename=_LOGFILENAME)
|
||
|
|
|
||
|
|
# Remove module name prefix from Warn/error messages emitted
|
||
|
|
# from here
|
||
|
|
set_formatter(log, 'stderr', 'brief')
|
||
|
|
|
||
|
|
# Define handlers for additional loggers
|
||
|
|
# Thoses logger are not for use
|
||
|
|
# Log pyeole.service
|
||
|
|
pyeole_service_log = init_logging(name=u'pyeole.service',
|
||
|
|
level=options.log_level,
|
||
|
|
filename=_LOGFILENAME,
|
||
|
|
console=['stderr'])
|
||
|
|
# Log pyeole.pkg
|
||
|
|
pyeole_pkg_log = init_logging(name=u'pyeole.pkg',
|
||
|
|
level=options.log_level,
|
||
|
|
filename=_LOGFILENAME)
|
||
|
|
passlib_log = init_logging(name=u'passlib.registry',
|
||
|
|
level='error',
|
||
|
|
filename=_LOGFILENAME)
|
||
|
|
|
||
|
|
# Disable warnings from pyeole.service
|
||
|
|
set_filters(pyeole_service_log, 'stderr',
|
||
|
|
['error', 'critical'])
|
||
|
|
|
||
|
|
if options.verbose or options.debug:
|
||
|
|
# Enable creole logs
|
||
|
|
creole_log = init_logging(name=u'creole', level=options.log_level,
|
||
|
|
filename=_LOGFILENAME)
|
||
|
|
# Define a root logger when verbose or debug is activated
|
||
|
|
root_log = init_logging(level=options.log_level)
|
||
|
|
else:
|
||
|
|
# Enable creole logs
|
||
|
|
creole_log = init_logging(name=u'creole', level=options.log_level,
|
||
|
|
filename=_LOGFILENAME,
|
||
|
|
console=['stderr'])
|
||
|
|
|
||
|
|
creolemajauto_log = init_logging(name=u'creole.majauto', level=options.log_level,
|
||
|
|
filename=_LOGFILENAME, console=['stderr', 'stdout'])
|
||
|
|
|
||
|
|
ihm.print_title(_(u'Beginning of configuration'))
|
||
|
|
# instance or reconfigure ?
|
||
|
|
reset_compat_name()
|
||
|
|
fonctionseole.zephir("INIT", "Début de configuration",
|
||
|
|
COMPAT_NAME.upper())
|
||
|
|
prepare(need_lock)
|
||
|
|
valid_mandatory(need_lock)
|
||
|
|
cache()
|
||
|
|
containers()
|
||
|
|
packages()
|
||
|
|
run_parts(u'preservice')
|
||
|
|
services(action=u'stop')
|
||
|
|
run_parts(u'pretemplate')
|
||
|
|
templates()
|
||
|
|
if not is_valid_ip_eth0():
|
||
|
|
log.info(_(u"eth0 network interface does not have a valid IP address."))
|
||
|
|
log.info(_(u"Restarting networking service"))
|
||
|
|
manage_service(u'restart', u'networking', display='console')
|
||
|
|
templates()
|
||
|
|
if not is_valid_ip_eth0():
|
||
|
|
log.info(_(u"eth0 network interface does not have a valid IP address."))
|
||
|
|
msg = _(u"Unable to obtain IP address.")
|
||
|
|
raise NetworkConfigError(msg)
|
||
|
|
|
||
|
|
services(action=u'configure')
|
||
|
|
# posttemplate/00-annuaire needs the certificates
|
||
|
|
certificates()
|
||
|
|
run_parts(u'posttemplate')
|
||
|
|
#close all connexion before param kernel #17408
|
||
|
|
client.close()
|
||
|
|
param_kernel()
|
||
|
|
kill_dhclient()
|
||
|
|
services(action=u'start')
|
||
|
|
users()
|
||
|
|
run_parts(u'postservice')
|
||
|
|
schedule()
|
||
|
|
finalize(need_lock)
|
||
|
|
ihm.print_title(_(u'Reconfiguration OK'))
|
||
|
|
update_server()
|
||
|
|
# IMPORTANT : Ne rien faire après ces lignes
|
||
|
|
# car le serveur est susceptible d'être redémarré
|
||
|
|
reboot_server()
|
||
|
|
|
||
|
|
except (UserExit, UserExitError), err:
|
||
|
|
unlock_actions(need_lock)
|
||
|
|
fonctionseole.zephir("FIN", "Abandon par l'utilisateur",
|
||
|
|
COMPAT_NAME.upper())
|
||
|
|
raise err
|
||
|
|
|
||
|
|
except Exception, err:
|
||
|
|
if options.debug:
|
||
|
|
log.debug(err, exc_info=True)
|
||
|
|
else:
|
||
|
|
log.error(err)
|
||
|
|
fonctionseole.zephir('ERR', str(err),
|
||
|
|
COMPAT_NAME.upper(),
|
||
|
|
console=False)
|
||
|
|
if need_lock:
|
||
|
|
release(LOCK_NAME, valid=False, level='system')
|
||
|
|
raise err
|
||
|
|
|
||
|
|
if __name__ == '__main__':
|
||
|
|
main()
|