[Script/Tuto] Amorcer une image iso sans clé USB ni lecteur de CD-ROM

subprocess.call("umount /tmp/iso".split())

code_de_retour = subprocess.call("umount /tmp/iso".split())

### BEGIN /etc/grub.d/41_custom ###
if [ -f  $prefix/custom.cfg ]; then
  source $prefix/custom.cfg;
fi
### END /etc/grub.d/41_custom ###

#######################################################################################################################
# Avertissement présenté à l'utilisateur si le fichier iso est introuvable, ou n'a pas été donné en paramètre de la commande iso_boot
#   Iso file missing
function no_iso_file {
  if [ -n "${1}" ] ; then
    echo L\'image à partir de laquelle il faut amorcer le PC, ${1}, ne se trouve sur aucun des supports actuellement raccordés à l\'ordinateur.
  else 
    echo Aucune image iso n\'a été attachée au libellé ${chosen} que vous venez de choisir.
  fi
}
#######################################################################################################################
# Avertissement présenté à l'utilisateur si le fichier de configuration est introuvable
#   Grub configuration file missing
function no_cfg_file {
  echo Le fichier de configuration, ${1}, ne se trouve sur aucun des supports actuellement raccordés à l\'ordinateur.
 }
#######################################################################################################################
function iso_boot  {
#
# Cette procédure crée un periphérique virtuel qui donne accès aux répertoires et fichiers contenu dans le fichier iso
# et cherche le fichier contenant le menu correspondant à l'image iso considérée et l'introduit dans le menu Grub
# paramètre ${1} : le nom du fichier iso, chemin d'accès compris, dans la partition où il se trouve, en commençant par /
# paramètre ${2}, facultatif : idem pour le fichier contenant les entrées de menu pour l'image iso considérée
#    quand il est omis, il s'agit du fichier /boot/grub/loopback.cfg de l'image iso
  set image_iso=
  set iso_path="${1}"
#  recherche du fichier iso
  if [ -n "${1}" ]; then
# si le fichier ${1} de nom /..../nom existe, alors cela signifie qu'il est sur la partition ${root}
     if [ -e "${1}" ]; then set image_iso=${root}; else search --file --set=image_iso --no-floppy "${1}"; fi
  fi
  if [ -z "${image_iso}" ]; then no_iso_file "${1}";  sleep -v 10; fi
# création du périphérique virtuel qui donne accès au fichier iso
#    creation of the virtual device holding the iso file and paths initialisation
   loopback iso (${image_iso})${1}
   set root=iso
   set loopcfg=
# recherche et introduction du menu spécifique à l'image iso considérée
   if [ -z "${2}" ]; then set sourcefile=/boot/grub/loopback.cfg; else set sourcefile="${2}"; fi
# si le fichier se trouve sur le périphérique $root, il n'est pas utile de le chercher
   if [ -e "${sourcefile}" ]; then set loopcfg=${root} ; else search --file --set=loopcfg --no-floppy "${sourcefile}" ; fi
   if [ -z "${loopcfg}" ]; then no_cfg_file "${sourcefile}"; sleep -v 10; else source "(${loopcfg})${sourcefile}"; fi
}
function amorce_iso {
########################################################################################
#
# amorçage par le script shell iso_boot.sh
#
#######################################################################################
# pour éviter le bouclage sur la procédure
    if ${amorceiso}; then
        set amorceiso=false
        save_env amorceiso
        if ! keystatus --ctrl; then
            if ! keystatus --shift; then
                set image_iso=
                set iso_path="${1}"
                set iso_file="${1}"
                if [ -e "${1}" ]; then set image_iso="${root}"; else search --file --set=image_iso --no-floppy "${1}"; fi
                loopback iso (${image_iso})${1}
                set root=iso
                if [ -e "${2}" ]; then set loopcfg=${root} ; else search --file --set=loopcfg --no-floppy "${2}" ; fi
                export iso_path
                export iso_file
                export root
                configfile "(${loopcfg})${2}"
                fi
            fi
        fi
}

 source ${prefix}/greffons/fonctions_iso.cfg

submenu "file.iso" { iso_boot "path/to/file.iso" "path/to/loopback.cfg" }

sudo pip-3.2 install path.py

#!/usr/bin/env python3
# -*- coding:utf-8 -*-

from os.path import expanduser
import argparse
import fonctions
import subprocess

### Programme principal ###
# Initialisation des arguments à passer au programme
parser = argparse.ArgumentParser(description='''Modifie les fichiers de configuration de GRUB afin de démarrer l'ordi sur une image iso.''', prog='GRUB Enhancer')

parser.add_argument('-i', '--iso', required=True, metavar='FILE', help="L'image iso destinée à être bootée")
parser.add_argument('-l', '--loop', metavar='FILE', default="", help="Le fichier loopback qui y est associé")
parser.add_argument('--grub-rep', metavar='DIRECTORY', dest='rep', default='/boot/grub/', help="Un éventuel répertoire alternatif pour GRUB. Default=/boot/grub/")
parser.add_argument('-r', '--reboot', const=True, default=False, action='store_const', dest='reboot', help="Redémarre l'ordinateur après les modifications")
parser.add_argument('-t', '--temporary', const=True, default=False, action='store_const', dest='temp', help="N'effectue la modification que pour le prochain redémarrage")

args = parser.parse_args()
# Support du tilde ( ~ )
args.iso = expanduser(args.iso)
args.rep = expanduser(args.rep)
if args.loop: args.loop = expanduser(args.loop)
else: args.loop = None

# Vérification des droits root
if fonctions.check_root(): pass
else:
    print("Ce programme demande les droits root.")
    exit()

print("Vérification de la configuration de GRUB...")
fonctions.check_grub_config()
fonctions.update_grub(args.rep)

print("Écriture des fonctions nécessaire aux démarrage sur une image iso...")
fonctions.write_function(args.rep)

print("Modification du fichier de menu...")
fonctions.update_custom(args.iso, args.rep, args.loop, args.temp)

if args.reboot: subprocess.call("shutdown -r now".split())

#! /usr/bin/env pyhton3
# -*- coding:utf-8 -*-

import path
import subprocess
import os
import shlex
from os.path import basename

def search(dir, pattern, rec=1):
    """Fonction de recherche de répertoire selon un «pattern».
    <rec> indique le niveau de récursivité.
    Renvoie une liste contenant les chemins correspondant au pattern."""
    dir = path.Path(dir)
    result = list()
    for i in range(rec):
        result += dir.glob('*/'*i + pattern)
    return result

def check_grub_config(rep="/etc/grub.d/", custom_conf="custom.cfg"):
    """Vérifie la présence du fichier «41_custom» dans le
    répertoire "/etc/grub.d". Le crée sinon avec le contenu
    de custom.cfg"""
    grub_dir = path.Path(rep)
    files = grub_dir.files()
    if "41_custom" in files: return True
    else:
        custom_content = open(custom_conf, 'r').read()
        custom = grub_dir.joinpath("41_custom")
        custom = custom.open('w')
        custom.write(custom_content)
        custom.close()
        return True

def update_grub(rep="/boot/grub/"):
    """Met à jour la configuration de grub"""
    grub_dir = path.Path(rep)
    config_file = grub_dir.joinpath("grub.cfg")
    commande = "grub-mkconfig -o {}".format(config_file)
    subprocess.call(commande.split())
    return True

def check_root():
    """Vérifie que le programme a les droits root.
    Renvoie True si c'est le cas, False sinon."""
    if os.geteuid() == 0:
        return True
    else:
        return False

def write_function(rep, file="fonctions_iso.cfg"):
    """Écrit les fonctions nécessaires au démarrage
    sur iso dans le répertoire grub. Les fonctions sont
    lues à partir de «file»"""
    grub_dir = path.Path(rep)
    fonctions = open(file, 'r').read()
    try:
        grub_dir.joinpath("greffons").mkdir()
    except OSError: pass
    fonctions_file = grub_dir.joinpath("greffons/fonctions_iso.cfg")
    fonctions_file = fonctions_file.open('w')
    fonctions_file.write(fonctions)
    fonctions_file.close()
    return True

def update_custom(iso, rep="/boot/grub", loop=None, temp=False):
    """Modifie le fichier contenant les entrées du menu"""
    incipit = "source ${prefix}/greffons/fonctions_iso.cfg\n"
    grub_dir = path.Path(rep)
    custom = grub_dir.joinpath("custom.cfg")
    try: custom_content = custom.open('r').readlines()
    except OSError: custom_content = []
    
    # Rajout de l'incipit
    if incipit not in custom_content:
        custom_content[:0] = [incipit]
    
    # Suppression des instructions «amorce_iso»
    for line in custom_content:
        if "amorce_iso" in line:
            custom_content.remove(line)
    
    # Calcul des chemins depuis la racine de la partition
    iso = find_path(iso)
    if loop: loop = find_path(loop)
    
    # Obtention du nom de l'iso
    iso_name = basename(iso)
    
    if temp:
        if loop:
            config = 'amorce_iso "{}" "{}"\n'.format(iso, loop)
        elif not loop:
            config = 'amorce_iso "{}"\n'.format(iso)
        subprocess.call('grub-editenv /boot/grub/grubenv set amorceiso=true'.split())
    elif not temp:
        if loop:
            config = '\tsubmenu "'+iso_name+'" {iso_boot "'+iso+'" "'+loop+'"}\n'
        elif not loop:
            config = '\tsubmenu "'+iso_name+'" {iso_boot "'+iso+'"}\n'
    
    custom_content.append(config)
    custom_content = "".join(custom_content)
    
    custom = custom.open('w')
    custom.write(custom_content)
    custom.close()
    
    return True
    
def find_path(path):
    """Retrouve le chemin d'accès d'un fichier à partir de la racine
    de sa partition et non du système. Utilise le programme df"""
    # Redirection du retour du programme df dans un fichier que l'on va 
    # ensuite lire puis supprimer
    commande = shlex.split('bash -c "df {} > partition"'.format(path))
    subprocess.call(commande)
    resultat = open('partition', 'r').read()
    partition = resultat.split()[-1]
    os.remove("partition")
    # Puis suppression dans le chemin donné de la partition
    path = path.replace(partition, "", 1)
    return path

#!/bin/sh
cat <<EOF
if [ -f  \${config_directory}/custom.cfg ]; then
  source \${config_directory}/custom.cfg
elif [ -z "\${config_directory}" -a -f  \$prefix/custom.cfg ]; then
  source \$prefix/custom.cfg;
fi
EOF

locale=fr_FR bootkbd=fr console-setup/layoutcode=fr console-setup/variantcode=oss

Juste une question : est-ce que quelqu'un teste les scripts à part moi ? Histoire de faire des retours de bugs... Je sais pas si Babdu a vu qu'on avait repris le post...

sudo pip3 install path.py