Infra
/
rougail
9
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
rougail/upgrade/Upgrade-Auto

597 lines
19 KiB
Python
Executable File
Raw Blame History

#!/usr/bin/python -u
# -*- coding: utf-8 -*-
#
##########################################################################
# Maj-Auto - Manage automatique update of EOLE server
# Copyright © 2015 Pôle de compétences EOLE <eole@ac-dijon.fr>
#
# License CeCILL:
# * in french: http://www.cecill.info/licences/Licence_CeCILL_V2-fr.html
# * in english http://www.cecill.info/licences/Licence_CeCILL_V2-en.html
##########################################################################
import sys
import warnings
import apt
import atexit
from argparse import ArgumentParser
import locale
from pyeole.i18n import i18n
from pyeole import lock
from pyeole.process import system_code
from pyeole.ihm import print_title, print_red, print_green
from pyeole.ihm import question_ouinon
from creole.config import configeoldir
from os import system
from os import access
from os import R_OK
from os import mkdir
from os import unlink
from os.path import join
from os.path import isfile
from os.path import isdir
import time
import re
from shutil import copytree
from shutil import copy
from pyeole.pkg import EolePkg, _configure_sources_mirror
from creole.fonctionseole import controle_kernel, zephir
from creole.config import eoledir
from creole.config import templatedir
from creole.config import vareole
from creole.template import CreoleTemplateEngine
from creole.client import CreoleClient
from glob import glob
import hashlib
from urllib2 import urlopen
from urllib2 import ProxyHandler
from urllib2 import build_opener
from HTMLParser import HTMLParser
warnings.filterwarnings("ignore", "apt API not stable yet", FutureWarning)
_ = i18n('update-manager')
if not isfile(join(configeoldir, '.upgrade_available')):
print ""
print_red(_(u'Upgrade to a newer major version is not available'))
print _(u'Use Maj-Release script to upgrade to next minoir version')
print ""
sys.exit(1)
from UpdateManager.Core.MetaRelease import MetaReleaseCore
from UpdateManager.Core.DistUpgradeFetcherCore import DistUpgradeFetcherCore
from DistUpgrade.utils import init_proxy
quit_re = re.compile(r'q|(quit)|(exit)|(abort)', re.I)
tmp_dir = '/tmp/Upgrade-Auto'
def release_lock():
if lock.is_locked('upgrade-auto', level='system'):
lock.release('upgrade-auto', level='system')
class EOLEDistUpgradeFetcherCore(DistUpgradeFetcherCore):
def verifyDistUprader(self, *args, **kwargs):
copy(join(tmp_dir, 'DistUpgradeViewEOLE.py'), self.tmpdir)
return super(EOLEDistUpgradeFetcherCore, self).verifyDistUprader(*args, **kwargs)
def cli_choice(alternatives, prompt, title=None, guess=False):
"""
Display choices in terminal and return chosen one
:param alternatives: choices proposed to user
:type alternatives: list
:param guess: wether to guess choice
:type guess: boolean
"""
def default_input(alt_mapping, prompt, title=None, guess=False):
choices = "\n".join(["[{0}] {1}".format(alt[0], alt[1])
for alt in alt_mapping.items()])
choices = _(u"Available choices:\n{}\n").format(choices)
if title is not None:
print_green(title)
print choices
if guess is True and len(alt_mapping) < 2:
print_green(_(u"Automatically selected first choice: {}\n").format(alt_mapping[1]))
choice = "1"
else:
try:
prompt = prompt + _(u"\n[1]: ")
choice = raw_input(prompt)
except KeyboardInterrupt, EOFError:
print _("\nUpgrade aborted by user")
sys.exit(0)
if choice == '':
choice = "1"
return choice
alt_mapping = {num + 1: choice for num, choice in enumerate(alternatives)}
choice = default_input(alt_mapping, prompt, title=title, guess=guess)
if choice not in alt_mapping.values():
try:
choice = alt_mapping[int(choice)]
except KeyError:
print _("Choice {} not available\n").format(choice)
choice = cli_choice(alternatives, prompt, guess=guess)
except ValueError:
if quit_re.match(choice):
print _("Upgrade cancelled by user")
sys.exit(0)
else:
print _("Invalid input: {}\n").format(choice)
choice = cli_choice(alternatives, prompt, guess=guess)
return choice
def upgrade_container_source(container):
"""Edit source list in container
:param container: container name
:type container: str
"""
print 'changement des sources.list pour le conteneur ', container
source_list = '/opt/lxc/{}/rootfs/etc/apt/sources.list'.format(container)
with open(source_list) as old_source:
sources = old_source.read()
with open(source_list, 'w') as new_source:
new_source.write(sources.replace('precise', 'trusty'))
cmd = ['apt-get', 'update']
code = system_code(cmd, container=container)
return code
ALTERNATIVES = ("2.5.1", )
RUNPARTS_CMD = u'/bin/run-parts --exit-on-error -v {directory}'
PRE_DOWNLOAD = 'pre_download'
UPGRADE_DIR = join(eoledir, 'upgrade')
ISO_DIR = join(vareole, 'iso')
ISO_URL_BASE = 'http://eole.ac-dijon.fr/pub/iso'
z_proc = "UPGRADE"
class ExtractEOLEVersions(HTMLParser):
"""Extrat stable EOLE versions from HTML page
Gathered versions are stored in ``self.versions``.
"""
def __init__(self, version):
HTMLParser.__init__(self)
self.version = version
self.versions = []
self.process_a = False
def handle_starttag(self, tag, attrs):
if tag != 'a':
self.process_a = False
return
self.process_a = True
def handle_data(self, data):
if not self.process_a:
return
# Strip not matching and pre stable versions
if data.lower().startswith(self.version) and '-' not in data:
self.versions.append(data.rstrip('/'))
def get_most_recent_version(match, url, proxy=None):
"""Get the most recent matching version
"""
if proxy is not None:
proxy_handler = ProxyHandler({'http': proxy,
'https': proxy})
else:
proxy_handler = ProxyHandler({})
opener = build_opener(proxy_handler)
http_request = opener.open(url)
html_parser = ExtractEOLEVersions(match)
html_parser.feed(http_request.read())
html_parser.versions.sort()
return html_parser.versions[-1]
def build_iso_name(version):
"""Build ISO name for version
"""
arch = apt.apt_pkg.config.get('APT::Architecture')
iso_name = 'eole-{version}-alternate-{arch}.iso'.format(version=version,
arch=arch)
return iso_name
def build_release_url(version, proxy=None):
"""Build the URL of latest release of a version
"""
version_url = ISO_URL_BASE + '/EOLE-' + '.'.join(version.split('.')[0:2])
latest_version = get_most_recent_version(version, version_url, proxy)
release_url = '{base}/{release}'.format(base=version_url,
release=latest_version)
return release_url
def check_iso(iso_name, path, release_url, proxy=None):
"""Verify checksum and signature
"""
sha256_file = join(ISO_DIR, 'SHA256SUMS')
sha256_url = release_url + '/SHA256SUMS'
sha256_gpg_file = join(ISO_DIR, 'SHA256SUMS.gpg')
sha256_gpg_url = sha256_url + '.gpg'
sha256 = hashlib.sha256()
iso_ok = False
print _(u"Verifying ISO image {iso}").format(iso=path)
if not isfile(sha256_file):
print _(u"Download SHA256SUMS file")
download_with_wget(sha256_file, sha256_url, proxy)
if not isfile(sha256_gpg_file):
print _(u"Download SHA256SUMS.gpg file")
download_with_wget(sha256_gpg_file, sha256_gpg_url, proxy)
print _(u"Check SHA256SUMS file signature")
gpg_cmd = ['gpgv', '-q', '--keyring',
'/etc/apt/trusted.gpg.d/eole-archive-keyring.gpg',
sha256_gpg_file, sha256_file]
ret = system_code(gpg_cmd)
if ret == 0:
print _(u"Check ISO SHA256..."),
sha_fh = open(sha256_file, 'r')
for line in sha_fh:
sha, filename = line.split()
if filename != '*{iso_name}'.format(iso_name=iso_name):
continue
with open(path, 'rb') as iso_fh:
while True:
block = iso_fh.read(2**10)
if not block:
break
sha256.update(block)
iso_ok = sha == sha256.hexdigest()
if iso_ok:
print _(u'OK')
return True
print _(u'Error')
# Default
return False
def download_with_wget(out_file, url, proxy=None, limit_rate="0"):
"""Use wget to download a file with a progress bar and rate limit
"""
wcmd = ['wget', '-c', '--progress', 'dot:giga']
if limit_rate != '0':
wcmd.extend(['--limit-rate', limit_rate])
wcmd.extend(['-O', out_file, url])
if proxy is not None:
env = {'http_proxy': proxy,
'https_proxy': proxy}
else:
env = {}
if not system_code(wcmd, env=env) == 0:
err_msg = _("Error downloading {file} with wget from {url}")
err_msg = err_msg.format(file=out_file, url=url)
zephir("ERR", err_msg, z_proc)
raise SystemError(err_msg)
def download_iso_with_zsync(iso_file, iso_url):
"""Use zsync to download the ISO
"""
zcmd = ['zsync', '-o', iso_file, iso_url + '.zsync']
if not system_code(zcmd) == 0:
err_msg = _("Error downloading the image with zsync")
zephir("ERR", err_msg, z_proc)
raise SystemError(err_msg)
def clean_iso_dir(iso_file=None):
"""Clean ISO directory
If :data:`iso_file` is not `None`, it's keept
"""
# Remove any file other than targeted release ISO
# This permit to resume download
for filename in glob('{iso_dir}/*'.format(iso_dir=ISO_DIR)):
if filename == iso_file:
continue
unlink(filename)
def get_cdrom_device():
device = None
client = CreoleClient()
mount_point = '/media/cdrom'
mounted = False
if not isdir(mount_point):
mkdir(mount_point)
for cdrom in client.get_creole('cdrom_devices'):
cmd = ['/bin/mount', cdrom, mount_point, '-o', 'ro']
if system_code(cmd) != 0:
continue
mounted = True
if isdir('{0}/dists'.format(mount_point)):
device = cdrom
cmd = ['/bin/umount', mount_point]
if system_code(cmd) != 0:
err_msg = _("Unable to umount {cdrom}").format(cdrom=cdrom)
zephir("ERR", err_msg, z_proc)
raise SystemError(err_msg)
if device is not None:
break
return device
def download_iso(args):
"""Download ISO image
Download an ISO image from internet or copy one from :data:`path`.
:parameter path: path of an existing ISO image
:type path: `str`
"""
proxy = None
client = CreoleClient()
if client.get_creole('activer_proxy_client') == u'oui':
address = client.get_creole('proxy_client_adresse')
port = client.get_creole('proxy_client_port')
proxy = 'http://{address}:{port}'.format(address=address, port=port)
release_url = build_release_url(args.release, proxy)
iso_name = build_iso_name(args.release)
iso_file = join(ISO_DIR, iso_name)
iso_url = '{url}/{iso}'.format(url=release_url, iso=iso_name)
print_title(_(u"Downloading ISO image for {release}").format(release=args.release))
if not isdir(ISO_DIR):
mkdir(ISO_DIR)
if isfile(iso_file) and check_iso(iso_name, iso_file, release_url, proxy):
# ISO is downloaded and verified
return True
# Remove SHA265SUMS* files
# Keep ISO to resume download if possible
clean_iso_dir(iso_file)
err_msg = None
if args.cdrom or args.iso is not None:
if args.cdrom:
path = get_cdrom_device()
if path is None:
err_msg = _("No CDROM found")
else:
path = args.iso
if not isfile(path):
err_msg = _("No such file: {iso}").format(iso=path)
elif not access(path, R_OK):
err_msg = _("Unreadable file: {iso}").format(iso=path)
if err_msg is None:
# Should we also check source image before copying?
# elif not check_iso(iso_name, path, release_url):
# raise SystemError("ISO image is not valid for {iso}".format(iso=path))
print _("Copying {source} to {iso}").format(source=path, iso=iso_file)
copy(path, iso_file)
if not check_iso(iso_name, iso_file, release_url, proxy):
# Copy was OK but check fails
# Remove copied ISO as it may be corrupted and prevent
# futur download
clean_iso_dir()
msg = _("Error checking ISO after copy, remove {iso}")
err_msg = msg.format(iso=iso_file)
else:
# Try resuming download
download_with_wget(iso_file, iso_url, proxy, args.limit_rate)
# download_iso_with_zsync(iso_file, iso_url)
if not check_iso(iso_name, iso_file, release_url, proxy):
# Download was OK but check fails
# Remove downloaded ISO as it may be fully downloaded but
# corrupted and prevent futur download
clean_iso_dir()
msg = _(u"Error checking ISO image after download, remove {iso}")
err_msg = msg.format(iso=iso_file)
if err_msg:
zephir('ERR', err_msg, z_proc)
raise SystemError(err_msg)
def main():
args_parser = ArgumentParser(description=_("EOLE distribution upgrade tool."))
args_parser.add_argument('--release',
help=_(u"Target release number"))
args_parser.add_argument('--download', action='store_true',
help=_(u"Only download the ISO image"))
args_parser.add_argument('--iso', metavar=u'PATH',
help=_(u"Path to an ISO image"))
args_parser.add_argument('--cdrom', action='store_true',
help=_(u"Use CDROM device instead of downloading ISO image"))
args_parser.add_argument('--limit-rate', metavar=u'BANDWIDTH', default='120k',
help=_(u"Pass limit rate to wget. “0” to disable."))
args_parser.add_argument('-f', '--force', action='store_true',
help=_(u"Do not ask confirmation"))
args = args_parser.parse_args()
try:
locale.setlocale(locale.LC_ALL, "")
except:
pass
print_red(_(u"This script will upgrade this server to a new release"))
print_red(_(u"Modifications will be irreversible."))
init_proxy()
zephir("INIT", _(u"Starting Upgrade-Auto ({})").format(" ".join(sys.argv[1:])), z_proc)
# Ask for release if none provided on command line
if args.release is not None:
if args.release not in ALTERNATIVES:
msg = _(u"Invalid release {version} use: {values}")
err_msg = msg.format(version=args.release,
values=', '.join(ALTERNATIVES))
zephir("ERR", err_msg, z_proc)
print err_msg
sys.exit(1)
else:
title = _(u"Choose which version you want to upgrade to\n")
prompt = _(u"Which version do you want to upgrade to (or 'q' to quit)?")
args.release = cli_choice(ALTERNATIVES, prompt, title=title, guess=False)
if not args.force:
confirmation_msg = _(u"Do you really want to upgrade to version {}?")
if question_ouinon(confirmation_msg.format(args.release)) != 'oui':
end_msg = _(u'Upgrade cancelled by user')
zephir("FIN", end_msg, z_proc)
print end_msg
sys.exit(0)
lock.acquire('upgrade-auto', valid=False, level='system')
atexit.register(release_lock)
if not args.download:
print_title(_("Check update status"))
PKGMGR = EolePkg('apt', ignore=False)
PKGMGR.set_option('APT::Get::Simulate', 'true')
_configure_sources_mirror(PKGMGR.pkgmgr)
PKGMGR.update(silent=True)
upgrades = PKGMGR.get_upgradable_list()
for container, packages in upgrades.items():
if packages:
err_msg = _(u"Some packages are not up-to-date!")
zephir("ERR", err_msg, z_proc)
print_red(err_msg)
print_red(_(u"Update this server (Maj-Auto) before another attempt to upgrade"))
sys.exit(1)
print_green(_(u'Server is up-to-date'))
if controle_kernel():
err_msg = _(u"In order to upgrade, most recent kernel endorsed for this release must be used")
zephir("ERR", err_msg, z_proc)
print_red(err_msg)
sys.exit(1)
print_green(_(u'This server uses most recent kernel'))
download_iso(args)
if args.download:
end_msg = _(u"Download only detected, stop")
print_green(end_msg)
zephir("FIN", end_msg, z_proc)
sys.exit(0)
print_title(_("Copying upgrade scripts"))
if isdir(tmp_dir):
err_msg = _(u"Directory {0} already exists").format(tmp_dir)
zephir("ERR", err_msg, z_proc)
print_red(err_msg)
sys.exit(1)
copytree(UPGRADE_DIR, tmp_dir)
pre_download = join(tmp_dir, PRE_DOWNLOAD)
print_title(_("Configuring upgrade"))
engine = CreoleTemplateEngine()
rootctx = {u'name': u'root', u'path': u''}
file_info = {'name': '/etc/update-manager/release-upgrades.d/eole.cfg',
'source': join(templatedir, 'eole.cfg'),
'full_name': '/etc/update-manager/release-upgrades.d/eole.cfg',
'activate' : True,
'del_comment': u'',
'mkdir' : False,
'rm' : False}
engine.prepare_template(file_info)
engine.process(file_info, rootctx)
_configure_sources_mirror(PKGMGR.pkgmgr, eole_release=args.release)
print_title(_("Module specific commands"))
code = system(RUNPARTS_CMD.format(directory=pre_download))
if code != 0:
err_msg = _(u'Error {0}').format(pre_download)
print_red(err_msg)
zephir("ERR", err_msg, z_proc)
sys.exit(1)
for container in (cont for cont in upgrades if cont != 'root'):
upgrade_container_source(container)
PKGMGR.dist_upgrade(container=container, silent=False)
m = MetaReleaseCore(useDevelopmentRelease=False,
useProposed=False)
# this will timeout eventually
while m.downloading:
time.sleep(0.5)
progress = apt.progress.text.AcquireProgress()
fetcher = EOLEDistUpgradeFetcherCore(new_dist=m.new_dist,
progress=progress)
fetcher.run_options += ["--mode=server",
"--frontend=DistUpgradeViewEOLE",
]
print_title(_("Upgrading server"))
fetcher.run()
# all lines below will not be executed
if __name__ == "__main__":
try:
main()
except (KeyboardInterrupt, EOFError):
print_red(_("\nUpgrade aborted by user"))
exit(0)
Reference in New Issue View Git Blame Copy Permalink