Ubuntu-fr

Laërte

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

@ Arbiel:

Voici ce que fais mon script :
Il vérifie que GRUB contient bien les lignes :

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

Si ce n'est pas le cas il les ajoute.

Ensuite il crée un fichier greffons/fonctions_iso.cfg qui contient ce que Babdu m'avait donné au post 35 :

#######################################################################################################################
# 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
}

Enfin, il crée le fichier custom.cfg (s'il n'existe pas) et y ajoute :

 source ${prefix}/greffons/fonctions_iso.cfg

Puis une ligne du type :

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

Le second script fait exactement la même chose que le script bash que j'avais donné, donc tu devrais pouvoir comprendre.

Voilà ! (je vais probablement poster une nouvelle version dans la journée, je t'expliquerai de nouveau ce que ça fait.)

Je n'ai pas tout compris pour la fonction amorce_iso... Ce n'était pas la fonction iso_boot qu'il fallait utiliser ?
Quant aux commandes grub-env, est-ce que tu pourrais m'expliquer précisément ce qu'elle fait, que je comprenne ce qui se passe ? Je me souviens effectivement que ton script permettait de n'enregistrer le menu de boot de l'iso qu'une seule fois, ce que le mien ne permet pas, puisqu'il écrit l'entrée de manière permanente à chaque fois... Pourrais-tu m'expliquer comment ça marchait  ?

Merci !

Arbiel

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

Bonsoir laerte

Je n'ai pas vu l'alerte indiquant ta nouvelle intervention. J'espère que tu ne t'es pas désespéré de mon silence.

J'ai fait une erreur en te disant de supprimer une partie du code de "fonctions_iso.cfg". Cette erreur provient de ce que j'avais oublié que j'avais prévu deux méthodes pour démarrer à partir d'une image iso et je n'ai gardé en mémoire que celle que j'utilise systématiquement, et qui n'est pas celle qui est mise en œuvre avec ta clé. Comme souvent, je n'ai pas assez réfléchi avant d'intervenir.

Pour démarrer à partir d'une image iso, il faut en quelque sorte intervenir sur le fichier grub.cfg. Ce fichier est créé par la commande grub-mkconfig (update-grub n'est autre chose que l'invocation de cette commande, avec l'indication du fichier de sortie : "grub-mkconfig -o /boot/grub/grub.cfg") à partir du fichier /etc/default/grub et des fichiers contenus dans le répertoire /etc/grub.d. Pour modifier le comportement de grub, beaucoup recommandent de modifier ces fichiers, éventuellement d'en créer de nouveaux dans /etc/grub.d et d'exécuter ensuite la commande update-grub.

Les distributions Ubuntu permettent d'utiliser une seconde méthode qui consiste à créer un fichier /boot/grub/custom.cfg, ou, s'il existe, à le modifier. Cette méthode présente l'avantage de ne pas nécessiter l'exécution de la commande update-grub. Elle se traduit par la présence à la fin du fichier grub.cfg de lignes créées par le fichier /etc/grub.d/41_custom

### BEGIN /etc/grub.d/41_custom ###
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

ou, dans les versions plus anciennes

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

Pour les distributions dans lesquelles le fichier grub.cfg ne contient pas ces lignes, il suffit de créer un fichier /etc/grub.d/41_custom, ou au delà (je veux dire par là /etc/grub.d/nn_custom, avec nn > 41) pour les créer :

#!/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

Lorsque j'ai décidé d'écrire un script grub pour faciliter le démarrage à partir d'un fichier iso, j'ai choisi d'utiliser le fichier custom.cfg. J'ai alors défini la commande "iso_boot" qui attend comme arguments la référence (le chemin d'accès) au fichier iso et, optionnellement, au fichier de configuration servant à créer les lignes du menu grub relatives au démarrage à partir du fichier iso. Cette fonction utilise les deux fonctions "no_iso_file" et "no_cfg_file" pour afficher les messages d'erreur correspondants. La ligne

   if [ -z "${2}" ]; then set sourcefile=/boot/grub/loopback.cfg; else set sourcefile="${2}"; fi

signifie qu'en l'absence du 2e paramètre, le fichier de configuration est le fichier loopback.cfg contenu dans le fichier.

Ces références devaient être données dans le "langage" grub, semblable à celui de GNU/Linux, mais néanmoins suffisamment différent pour présenter des difficultés pour quiconque n'en était pas familier. J'ai alors entrepris d'écrire le script bash pour créer automatiquement les lignes amorce_iso dans le fichier custom.cfg. Ce script étant exécuté sous GNU/Linux, j'ai introduit, outre l'introduction "permanente" dans le menu grub des lignes spécifiques à l'image iso choisie lors de l'exécution du script bash, la possibilité de réamorcer immédiatement, et une seule fois, à partir du fichier iso, sans afficher le menu grub correspondant au système en cours d'exécution, mais en affichant directement celui qui correspond à l'image iso. Ces deux options, introduction dans le menu grub ou substitution d'un nouveau menu, correspondent à deux commandes grub différentes : source et configfile. J'ai alors défini la commande "amorce_iso" pour ce second mode de fonctionnement.

La ligne "amorce_iso" introduite dans le fichier custom.cfg n'est pas effacée par grub. Il faut au redémarrage à partir de l'image la neutraliser pour éviter de boucler indéfiniment sur le démarrage à partir de l'image iso. Cette neutralisation est effectuée par la variable d'environnement "amorceiso" qui est remise à la valeur "false" lors du démarrage à partir de l'image iso, et qui doit être "true" pour activer le démarrage à partir du fichier iso.

Je n'ai pas encore eu le temps d'analyser "grub-imageboot". J'ai constaté qu'un nouveau fichier "60_grub-imageboot" dans le répertoire /etc/grub.d a été créé, mais je n'en ai pas compris le fonctionnement.

Arbiel

---

Arbiel Perlacremaz
LDLC Aurore NK3S-8-S4 Ubuntu 20.04, GNOME 3.36.8
24.04 en cours de tests
Abandon d'azerty au profit de bépo, de google au profit de Lilo et de la messagerie électronique violable au profit de Protonmail, une messagerie chiffrée de poste de travail à poste de travail.

Laërte

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

J'ai bien vu ton message. Je comprends mieux comment fonctionne ton script maintenant (pas très bon en bash... ^^ )

Je continue de l'étudier en détail pour recréer son fonctionnement histoire d'avoir des fonctions python équivalentes à tes fonctions bash, ça me permettra de les incorporer à l'interface graphique par la suite.

Je vais essayer de poster une nouvelle version bientôt.

Merci pour tes explications !

Laërte

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

Ok, mises à jour du script finies !

Il fonctionne maintenant en deux fichiers séparés : grubenhancer.py et fonctions.py
grubenhancer.py est le script qui doit être appelé en ligne de commande et fonctions.py celui qui contient les fonctions utilisées par le script.
La principale différence avec la précédente version est l'utilisation du module path.py qu'il faut installer avec pip :

sudo pip-3.2 install path.py

À adapter en fonction de votre version de python (peut être pip-3.2, pip-3.3 ou pip-3.4)

Ensuite créer un fichier grubenhancer.py comme suit :

#!/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())

et un fichier fonctions.py :

#! /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

Ainsi qu'un fichier custom.cfg contenant :

#!/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

Le script peut être appelé avec les paramètres suivants:
--iso permet de sélectionner un fichier iso
--loop permet de sélectionner un fichier loopback
--grub-rep permet de sélectionner un répertoire grub (/boot/grub/ par défaut)
--reboot permet de redémarrer l'ordi après l'exécution du script
--temporary permet de rendre la modification effective seulement pour le prochain redémarrage

Seule l'option --iso est obligatoire normalement mais le script ne fonctionnera pas si l'option --temporary est précisée sans --loop. Cette limitation est due aux fonctions grub d'Arbiel (la fonctions amorce_iso attend obligatoirement deux paramètres et ne permet pas d'utiliser le fichier loopback de l'iso)

@Arbiel:

Le script fonctionne normalement (j'ai testé certaines options) selon tes directives (pas de modification directe du fichier grub.cfg mais de /etc/grub.d.41_custom, permet les entrées temporaires et rend le fichier loopback facultatif parfois).
Si jamais tu avais prévu un autre comportement qui n'est pas présenté ici, précise-le moi et je le créerai. En attendant il ne me reste plus qu'à créer l'interface graphique. Est-ce que tu as trouvée une solution pour booter des isos qui ne sont pas basées sur Ubuntu ?

Voilà c'est tout !

Si tu pouvais juste rendre facultatif la précision du fichier loopback avec amorce_iso ce serait parfait ! (Pourquoi ne pas avoir fait que amorce_iso appelle iso_boot ? )

Merci pour ton travail !

Arbiel

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

Bonjour Laërte

J'ai modifié le script grub pour permettre l'appel de "amorce_iso"  avec un seul paramètre. J'ai rapidement testé, mais je n'ai pas testé l'absence de régression pour "iso_boot".

Je suis surpris que tu aies fractionné le code de ton script en deux fichiers. Il me semblerait plus facile, pour les utilisateurs, que tout soit regroupé et qu'il n'y ait pas à enregistrer quoi que ce soit ici ou là. En poursuivant dans cette idée, j'ai constaté que Python (Python3.4, pour les versions antérieures, je ne sais pas) permet, plutôt que de lire le script grub à partir d'un fichier, d'en affecter le contenu à une variable, par exemple "fonctions", ce qui donnerait, dans ta fonction "update_custom"

fonctions = """# fonctions_iso_V2-1.cfg
# 2015_01_26
#######################################################################################################################
# Redémarrage en cas d'absence ou d'indisponibilité des fichiers (fichier image iso ou fichier de configuration)
function rdmge {
	echo Le PC va redémarrer dans quelques secondes
	sleep -v 10
	reboot
}
#######################################################################################################################
# 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
	rdmge
}
#######################################################################################################################
# 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.
	rdmge
 }
#######################################################################################################################
# Contrôle de l'existence des fichiers
#
function existent_fichiers {
#  recherche du fichier iso
	if [ -n "${iso_file}" ]; then
# si grub trouve le fichier ${iso_file}, alors ce fichier est sur la partition ${root} ; sinon il faut chercher où il est.
		if [ -e "${iso_file}" ]; then set image_iso=${root}; else search --file --set=image_iso --no-floppy "${iso_file}"; fi
	fi
	if [ -z "${image_iso}" ]; then no_iso_file "${iso_file}"; 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})${iso_file}
	set root=iso
	set loopcfg=
# recherche et introduction du menu spécifique à l'image iso considérée
	if [ -z "${sourcefile}" ]; then set sourcefile=/boot/grub/loopback.cfg; 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}";  fi
}
#######################################################################################################################
# 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 chemin d'accès au fichier iso
# paramètre ${2}, facultatif : le chemin d'accès au 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
function iso_boot  {
	set image_iso=
	set iso_file="${1}"
	set iso_path="${1}"
	set sourcefile="${2}"
	existent_fichiers
	source "(${loopcfg})${sourcefile}"
}
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
		set image_iso=
		set iso_path="${1}"
		set iso_file="${1}"
		set sourcefile="${2}"
		existent_fichiers
		export iso_path
		export iso_file
		export root
		configfile "(${loopcfg})${sourcefile}"
        fi
}"""

Tu remarqueras que la première ligne porte un numéro de mise à jour, que je vais faire évoluer à chaque modification, même minime. Je te conseille de nommer ainsi le fichier que tu enregistres dans /boot/grub/greffons, ce qui te permet facilement de décider s'il convient ou non de l'enregistrer dans /boot/grub/greffons.

J'ai compris que ton script n'avait pas d'interface graphique. À quoi sert alors le paramètre "help=" dans les commandes "parser.add_argument" ? J'y ai relevé quelques "imperfections" mineures, dont je te fais part ci-dessous, au cas où ces commentaires apparaîtrait néanmoins aux yeux des utilisateurs :

parser.add_argument('-i', '--iso', required=True, metavar='FILE', help="L'image iso à utiliser pour redémarrer le PC")
parser.add_argument('-l', '--loop', metavar='FILE', default="", help="Le fichier de configuration pour l'affichage du menu")
parser.add_argument('--grub-rep', metavar='DIRECTORY', dest='rep', default='/boot/grub/', help="Le répertoire utilisé par grub au démarrage si celui-ci n'est pas /boot/grub/")
parser.add_argument('-r', '--reboot', const=True, default=False, action='store_const', dest='reboot', help="Redémarrer immédiatement l'ordinateur")
parser.add_argument('-t', '--temporary', const=True, default=False, action='store_const', dest='temp', help="N'effectuer la modification que pour le prochain redémarrage")

Je crois qu'il faut envisager la possibilité de lancer ton script à partir d'un lanceur sur lequel l'utilisateur pourrait faire glisser l'image iso, ou même par un menu contextuel obtenu par clic sur le bouton droit de la souris lorsqu'elle est positionnée sur une image iso, ou son fichier loopback. Ta fonction "fonctions.check_root" n'est pas appropriée pour ce mode de lancement. Dans cette idée, j'ai écrit il y a quelque temps un petit script bash que tu pourrais peut-être essayer de traduire en Python.

C'est ton interface graphique qui va donner à ton script toute sa valeur. Il faut donc la définir avec précaution.

Le script bash que j'ai écrit utilise zenity. Or zenity présente l'inconvénient de ne permettre la saisie que d'un seul élément à la fois, ce qui n'est pas assez ergonomique . À mon avis, il faudrait pouvoir saisir les informations dans un écran unique, contenant vraisemblablement plusieurs onglets, ou plusieurs parties parfaitement bien identifiées. Dans ces onglets, on peut penser à un regroupement des informations par nature ou par complexité. Par complexité, je veux dire ce qui demande une plus ou moins grande compréhension du démarrage d'un PC et qui pourrait être intitulé "Mode expert".

Les tests effectués par Babdu89 ont montré que certaines distributions n'acceptent pas d'espaces dans le chemin d'accès à l'image iso. La solution que j'avais l'intention d'introduire dans le script bash était de définir un lien physique à la racine de la partition, nommé par la concaténation d'un libellé, par exemple "amorce_iso" et de l'inode du fichier (ou tout autre procédé, par exemple un uuid, permettant de s'assurer que deux images iso de même nom, mais enregistrées dans deux répertoires différents, ne conduisent pas à deux liens physiques de même nom). En allant dans ce sens, il faudra probablement ajouter des paramètres pour l'appel de "iso-boot" pour présenter un libellé compréhensible par l'utilisateur.

Certaines distributions, et vraisemblablement celle qui t'intéressait quand tu as commencé à t'intéresser à ce sujet, ne sont pas compatibles avec le script grub. La solution tourne autour de l'utilisation de "memdisk", mais je n'ai pas encore approfondi.

Babdu89 avait également souhaiter qu'au démarrage l'image iso bascule en français et le clavier en "azerty". Le plus simple, dans un premier temps est que tu prévois deux nouveaux paramètres. Le clavier "azerty" n'est pas le seul utilisé en français. J'utilise "bépo". Mais tu peux certainement obtenir cette information dans le système et te passer des paramètres. Nous verrons plus tard comment passer ces informations au lancement de l'image.

Bon courage

Arbiel

---

Arbiel Perlacremaz
LDLC Aurore NK3S-8-S4 Ubuntu 20.04, GNOME 3.36.8
24.04 en cours de tests
Abandon d'azerty au profit de bépo, de google au profit de Lilo et de la messagerie électronique violable au profit de Protonmail, une messagerie chiffrée de poste de travail à poste de travail.

Laërte

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

Ça fait beaucoup tout ça... ^^

Pour le numéro de version, je note ça dans mon fichier TODO histoire de gérer les prochaines versions avec le script.

Pour le paramètre help='TEXT' des parser.add_argument, il définit le texte qui s'affiche lorsqu'on lance la fonction avec l'argument -h ou --help. C'est dans ces cas-là rt uniquement ceux-ci que le message écrit s'affiche.

Pour le clavier azerty c'est déjà rajouté dans ma version locale, je pensais l'avoir mis en ligne. Le script qui extrait le fichier loopback y ajoute la traduction francophone dans la foulée. Je ne le poste pas tout de suite il est en cours de modification et n'est pas utilisable pour le moment. Concrètement il rajoute dans le fichier loopback, à toutes les lignes commençant par linux :

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

Pour la séparation en plusieurs fichiers, je pense que ça reste une bonne idée de séparer les fonctions utilisées par le script du fonctionnement de celui-ci. Pareil pour le fait de mettre tes fonctions dans des fichiers au lieu de dans des variables. Lors de modifications ultérieures, ça évite que tout soit fait sur le même fichier, ce qui augmenterait les risques d'erreur. D'autant qu'avec l'ajout de l'interface graphique, le script risque de se compliquer, je préfère donc que tout soit bien compartimenté. Après, pour l'utilisateur, le seul côté gênant pour l'instant vient du fait qu'il doive créer tous ces fichiers lui-même, puisque leur contenu est posté dans le forum. Je pense d'ailleurs créer un dépôts sur github (dès que j'aurais compris comment fonctionne git...), de cette manière il sera possible de télécharger directement une archive et d’exécuter le script qu'il faut, sans se prendre la tête avec les fichiers autour...

Pour l'exécution du script par un menu contextuel ou autre, là ça ne relève plus de l'appli en elle-même mais d'un module de gestionnaire de fichier qu'il faudra que l'on crée à part. je sais que Dolphin peut faire ça avec un fichier .desktop placé dans le bon dossier, j'imagine qu'il y a un équivalent pour Nautilus. Mais là, je pense que pour l'instant c'est du bonus, on va déjà essayer de faire une appli qui marche. Parce qu'il reste du boulot en ce qui me concerne.

D'ailleurs tu mets le doigt dessus : pas d'interface graphique encore. Pour celle-ci je ne sais pas si tu vois bien à quoi ressemble une interface faite avec tkinter (exemple : https://3.bp.blogspot.com/-9GGOzb7SUzg/ … emes_2.PNG ) mais on peut faire des trucs assez complexes. Ça demande juste du temps... Pour l'instant je vais essayer de faire un truc assez simple mais qui reprend toutes les fonctions de mon script en ligne de commande.

Pour memdisk, j'ai testé chez moi avec grubimage-boot, et bah ça ne marche pas ! ^^ Le kernel commence à démarrer et s'arrête en cours de root route.

Et enfin, la création d'un lien logique, qui me plaît bien comme idée. Faut que je vois comment je peux rajouter ça.

Bref, beaucoup de choses, pas dit que j'aille très vite en plus (je débute toujours dans la programmation python et je fais régulièrement des recherches encore pour trouver comment faire ceci ou cela), donc je ne sais pas si je vais poster de nouvelles versions avant un moment, mais vous en faîtes pas, j'y travaille ! ^^

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...

Arbiel

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

Bonsoir Laërte

Pour ma part, je n'ai pas testé ton script. Je le testerai peut-être si j'en trouve le temps et en ai l'occasion, mais j'attends plutôt l'interface graphique car c'est vraiment cette interface qui lui donnera toute sa valeur.

C'est bien sûr à toi qu'il revient de définir l'organisation de tes fichiers et j'ai compris que tu as l'intention de les distribuer sous la forme d'une archive avec un script pour les copier à leur place. C'est effectivement une solution intéressante.

J'ai néanmoins quelques remarques à formuler sur ce que tu as présenté

1) le contrôle de l'exécution en mode root : à mon avis, elle dépend de ton application car si l'on veut envisager de la lancer à partir d'un lanceur ou par un élément de menu contextuel, c'est bien ton application qui doit gérer le dialogue

2) le passage de paramètres au lancement du noyau : il me semblerait préférable de les mémoriser dans une variable et ce qui te permettra de tester beaucoup plus facilement s'il faut l'insérer ou si elle est déjà présente sur la ligne linux

3) pour ce qui est de la langue et du clavier, je crois qu'il est nécessaire de les prévoir dans les paramètres, et dans ton interface graphique.

Arbiel

---

Arbiel Perlacremaz
LDLC Aurore NK3S-8-S4 Ubuntu 20.04, GNOME 3.36.8
24.04 en cours de tests
Abandon d'azerty au profit de bépo, de google au profit de Lilo et de la messagerie électronique violable au profit de Protonmail, une messagerie chiffrée de poste de travail à poste de travail.

Babdu89

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

Bonjour.

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...

Oui, oui, bien sur que je suis toujours le sujet.

Mais ce qui est intéressant pour le "novice" que je m'efforce de rester, c'est d'avoir le script "presque"final à tester, et de retourner au dev, ce qui ne va pas. Je ne pense pas qu'on en soit arrivé là.

Alors, si je peux me permettre d'intervenir en cours de dev. Voila ce que j'aimerais souligné.

Remarque et rappel.
Sur mes vieilles machines.
Je n'ai fais que tester des iso en 32 bit. Des iso Ubuntu et leurs variantes officielles.
Je lance les 12.04, 14.04, et 14.10 .
Mais dès que l'on s'en écarte, le script ne les lance plus.
Exemple, j'ai tenté de lancer des iso d'Hybryde (basées sur Ubuntu) . Çà ne marche pas . Le script bash me demande de choisir le Grub lanceur de l'iso, me demande d'indiquer le chemin de l'iso, trouve l'iso et la monte.
Soit çà ne va pas plus loin et redemande d'indiquer l'iso a nouveau.
Soit çà va un peut plus loin . Mais il y a un souci avec le "loopback.iso" , et çà en reste là.

Donc pour lancer une variété d'iso comme on peut le faire avec le "MultiSystem" de frafa, on en est encore loin...
Il y a peut-être des idées à reprendre dans les script de cet outils, par une lecture approfondie.
Je dis çà. Je ne suis pas codeur, ni même capable de faire le moindre script, alors...

Maintenant, avec les nouvelles machines, dont je ne suis pas possesseur, donc pas de tests possibles. Les iso vont surtout être en 64 bit et en UEFI. Et là, çà change beaucoup de choses . Il faudrait que ce qui est écrit soit aussi utilisable en ce mode.

Pour en revenir au MultiSystem, frafa l'a fait évoluer en ce sens, ce qui fait que les iso en UEFI sont maintenant lancées par le MultiSystem.

Je ne sais pas si ce que vous écrivez actuellement va dans ce sens?...

Grub2 et Grub/efi . Il y a pas mal de différence il me semble.

Si on veut que ce soit utilisable, pour "tout" , la prise en compte de l'UEFI va devenir incontournable. Sinon les script deviendront rapidement obsolètes, et il y a un risque de voir de moins en moins de contributeurs pour tester.

Bonne continuation, je continue de suivre en silence pour le moment.

@+.   Babdu89  .

---

J'ai découvert Ubuntu avec la 07.10.... Et alors?!...  Depuis je regarde de temps en temps si Windows marche toujours....

Laërte

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

J'ai fini ! (enfin)

Normalement ça devrait marcher.

Le script est ici : https://github.com/schyzophrene-asynchr … b-enhancer

Au programme, la rédaction d'un README, éventuellement l'ajout du support de memdisk, pour supporter autre chose que juste les isos basées sur Ubuntu.

Au niveau des dépendances, il faut avoir installé python3, python3-pyqt5, et avoir fait un

sudo pip3 install path.py

Cette dernière commande pourra être évitée plus tard.

J'attend les retours de bug pour corriger, l'appli doit être lancée en tant que root pour pouvoir appliquer les modifications.

Voilà ! ^^

PS : le script à éxécuter est main.py.

Arbiel

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

Bonsoir Laërte

Je viens, en migrant mon système vers LVM, de trouver une limitation à l'utilisation de ton script. Dans l'immédiat, il faut refuser (ne pas exécuter la commande grub-editenv) si /boot/grub est un volume logique LVM, ou si le système de fichier est l'un des suivants
btrfs
cpiofs
newc
odc
romfs
squash4
tarfs
zfs

Des explications sont disponibles dans cette page (en anglais)

Je ne suis pour l'instant pas en mesure de tester ton travail.

Par contre, à la lecture de l'intervention de Babdu89, j'ai réfléchi à l'impact potentiel de l'UEFI et il me semble qu'il n'y en a pas. Tout repose sur grub et grub fonctionne avec BIOS et UEFI. Mais il s'agit là d'une analyse qui ne permet pas de négliger la confirmation par des tests.

Arbiel

Arbiel

---

Arbiel Perlacremaz
LDLC Aurore NK3S-8-S4 Ubuntu 20.04, GNOME 3.36.8
24.04 en cours de tests
Abandon d'azerty au profit de bépo, de google au profit de Lilo et de la messagerie électronique violable au profit de Protonmail, une messagerie chiffrée de poste de travail à poste de travail.

Babdu89

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

Bonsoir.
@ Laërte .

Je tente de tester sur un Ubuntu 14.04 64 bit . je n'ai que çà de diponible.

J'ai installé git. Ok.
J'ai cloné ; https://github.com/schyzophrene-asynchr … b-enhancer   OK.
J'ai bien un dossier  grub-enhancer  dans mon dossier personnel, avec les dossier et fichiers dedans. Dont main.py .
J'ai installé les dépendances  ; python3 et python3-pyqt5   OK.

La commande d'installation du path ;

sudo pip3 install path.py

Ne marche pas. commande inconnue.

Comment lancer le script  main.py, j'ai des erreurs .

bernard@bernard-System-Product-Name:~$ cd grub-enhancer
bernard@bernard-System-Product-Name:~/grub-enhancer$ bash main.py
main.py: ligne 4: import : commande introuvable
main.py: ligne 5: import : commande introuvable
main.py: ligne 6: import : commande introuvable
main.py: ligne 7: import : commande introuvable
main.py: ligne 8: import : commande introuvable
main.py: ligne 9: import : commande introuvable
from: can't read /var/mail/os.path
from: can't read /var/mail/PyQt5.QtCore
main.py: ligne 12: Erreur de syntaxe près du symbole inattendu « ( »
main.py: ligne 12: `from PyQt5.QtWidgets import (QMainWindow, QApplication,'
bernard@bernard-System-Product-Name:~/grub-enhancer$ 

@+.   Babdu89  .

Dernière modification par Babdu89 (Le 13/05/2015, à 22:04)

---

J'ai découvert Ubuntu avec la 07.10.... Et alors?!...  Depuis je regarde de temps en temps si Windows marche toujours....

Laërte

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

@Babdu89

la commande pip3 est disponible avec le paquet python3-pip.
Le script s'exécute avec ./main.py tout simplement. Ou en précédant de python3, mais ce n'est pas nécessaire (c'est inclus dans le fichier).

N'hésite pas à faire régulièrement des git pull dans le répertoire, je mets souvent à jour.

@Arbiel

Je vais me renseigner pour comment détecter LVM ou le type de système de fichier en python.
Il faut annuler toute la procédure ou juste la commande grub-editenv ?
Après vérification, la commande grub-editenv n'est utile que lorsque l'iso est une iso temporaire. Est-ce que le reste du script fonctionne chez toi, ou bien est-il complètement inutilisable dans le cas de partition /boot sur LVM ou RAID ?

Pour information mon système est une Debian Testing 64bits avec un BIOS et tout marche bien.

Des informations sur comment booter d'autres isos que celles basées sur Ubuntu ?
J'ai essayé avec Arch Linux et Manjaro.
Les deux bootent, Arch s'arrête au moment de remplir le répertoire /dev, et Manjaro plante aussi, mais je ne sais pas où (merci Plymouth...)

Dernière modification par Laërte (Le 17/05/2015, à 22:58)

Babdu89

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

Bonsoir.

Je poste depuis une session live Ubuntu 15.04 lancée avec le script  python de Laërte.

Préparation de l'installation du script sur un Ubuntu 14.04.2 en 64 bit.

Installation des paquets  ; python3, python3-pyqt5, python3-pip

sudo apt-get install  # les trois paquets

Installation du patch; 

  sudo pip3 install path.py

Installation de git;

sudo apt-get install git

Clonage du projet;

git clone https://github.com/schyzophrene-asynchrone/grub-enhancer

Ce qui créé un dossier  "grub-enhancer"  dans le dossier personnel de l'Os.

Lancement de l'application, avec mise à jour du projet.

    cd grub-enhancer

    git pull

    sudo ./main.py

Une fenêtre s'ouvre ;

Je choisi le répertoire  /boot/grub   qui lancera l'iso en live.

Je donne le chemin de l'iso . Chez moi sur un hdd externe dans des dossiers successifs

/media/bernard/DONNEES_SATA_1_/ISO_LINUX/Ubuntu_15.04

Comme c'est une iso live qui n'a jamais été lancée avec le script de Arbiel. Je créé un nouveau fichier "ubuntu-15.04-desktop-i386.loopback.cfg"
J'ajoute ce qu'il faut dans ce fichiers pour que la session live démarre en Français.

Je cocher " Redémarrage plus tard" , et "Permanent"  pour avoir une entrée de lancement de l'iso au bas du menu Grub .

Dans le dossier  /boot/grub de l'Ubuntu 14.04.2 64 bit.
J'ai un dossier  "greffons" qui contient un fichier  "fonctions_iso.cfg".

# fonctions_iso_V2-1.cfg
# 2015_01_26
#######################################################################################################################
# Redémarrage en cas d'absence ou d'indisponibilité des fichiers (fichier image iso ou fichier de configuration)
function rdmge {
    echo Le PC va redémarrer dans quelques secondes
    sleep -v 10
    reboot
}
#######################################################################################################################
# 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
    rdmge
}
#######################################################################################################################
# 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.
    rdmge
 }
#######################################################################################################################
# Contrôle de l'existence des fichiers
#
function existent_fichiers {
#  recherche du fichier iso
    if [ -n "${iso_file}" ]; then
# si grub trouve le fichier ${iso_file}, alors ce fichier est sur la partition ${root} ; sinon il faut chercher où il est.
        if [ -e "${iso_file}" ]; then set image_iso=${root}; else search --file --set=image_iso --no-floppy "${iso_file}"; fi
    fi
    if [ -z "${image_iso}" ]; then no_iso_file "${iso_file}"; 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})${iso_file}
    set root=iso
    set loopcfg=
# recherche et introduction du menu spécifique à l'image iso considérée
    if [ -z "${sourcefile}" ]; then set sourcefile=/boot/grub/loopback.cfg; 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}";  fi
}
#######################################################################################################################
# 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 chemin d'accès au fichier iso
# paramètre ${2}, facultatif : le chemin d'accès au 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
function iso_boot  {
    set image_iso=
    set iso_file="${1}"
    set iso_path="${1}"
    set sourcefile="${2}"
    existent_fichiers
    source "(${loopcfg})${sourcefile}"
}
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
        set image_iso=
        set iso_path="${1}"
        set iso_file="${1}"
        set sourcefile="${2}"
        existent_fichiers
        export iso_path
        export iso_file
        export root
        configfile "(${loopcfg})${sourcefile}"
        fi
}

J'ai aussi un fichier  "custom.cfg"

source ${prefix}/greffons/fonctions_iso.cfg
	submenu "ubuntu-15.04-desktop-i386.iso" {iso_boot "/ISO_LINUX/Ubuntu_15.04/ubuntu-15.04-desktop-i386.iso" "/ISO_LINUX/Ubuntu_15.04/ubuntu-15.04-desktop-i386.loopback.cfg"}

Dans le dossier qui contient l'iso à lancer, j'ai à côté de celle-ci, un fichier "ubuntu-15.04-desktop-i386.loopback.cfg"

menuentry "Try Ubuntu without installing" {
	linux	/casper/vmlinuz locale=fr_FR bootkbd=fr console-setup/layoutcode=fr console-setup/variantcode=oss file=/cdrom/preseed/ubuntu.seed boot=casper iso-scan/filename=${iso_path} quiet splash ---
	initrd	/casper/initrd.lz
}
menuentry "Install Ubuntu" {
	linux	/casper/vmlinuz  file=/cdrom/preseed/ubuntu.seed boot=casper only-ubiquity iso-scan/filename=${iso_path} quiet splash ---
	initrd	/casper/initrd.lz
}
menuentry "Check disc for defects" {
	linux	/casper/vmlinuz  boot=casper integrity-check iso-scan/filename=${iso_path} quiet splash ---
	initrd	/casper/initrd.lz
}
menuentry "Test memory" {
	linux16	/install/mt86plus
}

Pour le français, j'ai ajouté,

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

Je redémarre sur le Ubuntu 14.04.2 64 bit. En bas du menu Grub, j'ai une entrée pour lancer la session live  Ubuntu 15.04 ...

Pour un premier essai, çà marche.  Bravo .  Laërte .

Avantage de ces scripts par rapport à ce qui est expliqué dans le doc, pour ajouter une entrée au menu Grub.
C'est que l'on stocke les iso n'importe où dans les disques de la config. Le script est capable d'aller les chercher.

Ce n'est pas le cas avec ce qui est expliqué dans la doc, il faut stocker les iso à la racine de la partition système de L'Os qui lance le script.

Bonne soirée.

@+.  Babdu89   .

Dernière modification par Babdu89 (Le 18/05/2015, à 00:47)

---

J'ai découvert Ubuntu avec la 07.10.... Et alors?!...  Depuis je regarde de temps en temps si Windows marche toujours....

Laërte

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

@Babdu89

Créer le fichier loopback n'est pas nécessaire. Il est généré par le script de la manière suivante : nom de l'iso - .iso final + .loopback.cfg
Il sera toujours à côté de l'iso, même si tu as ouvert un fichier ailleurs (qui ne sera pas supprimé).
Quant aux traductions française, j'avais prévu le coup, une entrée dans le menu "Loopback" de la fenêtre permet de les ajouter automatiquement.

Si tu ne charges pas de fichier loopback (la fenêtre de l'éditeur reste vide), l'iso sera amorcée avec le fichier loopback contenue dedans.

Est-ce que quelqu'un sait comment monter une partition sans avoir les droits root ?

Arbiel

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

Bonjour

Après vérification, la commande grub-editenv n'est utile que lorsque l'iso est une iso temporaire.

Oui, le problème ne concerne que l'exécution temporaire d'un fichier iso. Voici quelques explications que j'espère, bien qu'un peu longues, être suffisamment claires.

L'exécution temporaire s'appuie sur la variable d'environnement de grub que j'ai nommée "amorceiso". Les variables d'environnement de grub sont rassemblées dans le fichier grubenv. grub lui-même utilise la variable "recordfail" pour mémoriser le fait que la procédure de démarrage réussit ou échoue, de sorte que, au démarrage suivant un échec, la procédure se déroule différemment, et donc qu'elle ait des chances d'aboutir, permettant ainsi à l'utilisateur de disposer d'un système opérationnel pour analyser et potentiellement réparer ce qui n'a pas fonctionné.

Il se trouve que grub ne sait pas écrire sur un volume logique LVM (l'utilisation de RAID implique, je crois, celle de LVM) ni sur les systèmes de fichiers que j'ai mentionnés au point #60. À chaque démarrage, grub enregistre la réussite ou l'échec de la procédure de démarrage. Ayant comme objectif de migrer mon système sur LVM, je suis en train de faire des tests dans ce sens, et c'est ainsi que j'ai découvert cette limitation de grub.

L'exécution temporaire d'un fichier iso est déclenchée par le fait que la variable d'environnement "amorceiso" est positionnée à la valeur "true", ce qui est effectué dans ton script par la traduction en python de la commande bash "grub-editenv". Le script grub "fonctions_iso.cfg" la remet à la valeur "false" pour rendre l'exécution effectivement temporaire. Mais si grub ne sait pas écrire dans le fichier grubenv, la variable reste à la valeur "true" et le démarrage par le fichier iso devient non seulement permanent, mais systématique avec deux inconvénients :
1/ le retour à une situation "normale" nécessite une bonne connaissance du fonctionnement de nos scripts et des commandes à exécuter pour remettre "amorceiso" à la valeur "false"
2) en cas d'échec de la procédure de démarrage par le fichier iso, il faut alors disposer d'un autre support (CD-Rom, clé USB, disque externe, …) pour démarrer et se trouver en position pour réparer, avec bien évidemment la même difficulté que dans le cas précédent.

Je suis en train de tester une modification de "fonctions_iso.cfg" pour essayer au moins d'éviter le cas 2. L'idée est de demander à l'utilisateur, lorsque je m'aperçois que grub n'a pas réussi à réécrire dans grubenv, s'il veut amorcer avec le fichier iso, ou l'ignorer. Je suis obligé de prévoir un tel contournement même si tu sais éviter de tomber dans ce piège, l'utilisation de "fonctions_iso.cfg" pouvant avoir été mise en œuvre à la main sans passer par ton script, ou en passant par mon script bash, ou sa version actuelle s'il me prenait l'idée de le modifier malgré la disponibilité du tien.

Est-ce que le reste du script fonctionne chez toi, ou bien est-il complètement inutilisable dans le cas de partition /boot sur LVM ou RAID ?

Petite précision : si dans la plupart des cas, le répertoire grub est dans la partition /boot, ce n'est pas systématiquement le cas. Il s'agit donc plutôt de /boot/grub.
Je n'ai pas encore eu réellement le temps de tester, et surtout, mon répertoire grub étant sur LVM, je ne veux pas tester tant que subsistent les risques de bouclage que j'ai mentionnés plus haut.

Je vais me renseigner pour comment détecter LVM ou le type de système de fichier en python.

En bash, la commande grub-probe permet de déterminer sur quel support se trouve grubenv, ou la nature du système de fichier. Si ${grubdir} est le répertoire en question

disque=$(sudo grub-probe --target=disk "${grubdir}")
syst_fic=$(sudo grub-probe --target=fs "${grubdir}")

Si ${disque} commence par /dev/mapper, /dev/dm ou /dev/md, ou dans le cas contraire, si ${syst_fic} est l'un des systèmes de fichiers du #60, il faut refuser la demande d'exécution temporaire.

Est-ce que quelqu'un sait comment monter une partition sans avoir les droits root ?

A priori

       The non-superuser mounts.
              Normally,  only  the  superuser can mount filesystems.  However,
              when fstab contains the user option on a line, anybody can mount
              the corresponding system.

              Thus, given a line

                     /dev/cdrom  /cd  iso9660  ro,user,noauto,unhide

              any  user  can  mount  the iso9660 filesystem found on his CDROM
              using the command

                     mount /dev/cdrom

              or

                     mount /cd

              For more details, see fstab(5).  Only the user  that  mounted  a
              filesystem  can unmount it again.  If any user should be able to
              unmount, then use users instead of user in the fstab line.   The
              owner option is similar to the user option, with the restriction
              that the user must be the owner of the special file. This may be
              useful e.g. for /dev/fd if a login script makes the console user
              owner of this device.  The group option  is  similar,  with  the
              restriction  that  the  user  must be member of the group of the
              special file.

Créer le fichier loopback n'est pas nécessaire

Ceci n'est vrai que si l'iso contient le fichier loopback.cfg, ce qui n'est pas garanti.

Pour le français, j'ai ajouté,
locale=fr_FR bootkbd=fr console-setup/layoutcode=fr console-setup/variantcode=oss

Comment modifier pour le clavier bépo ? Et ceci ne pourrait-il pas être déduit par analyse du système actif lors de l'exécution du script ?

Quant aux traductions française, j'avais prévu le coup, une entrée dans le menu "Loopback" de la fenêtre permet de les ajouter automatiquement.

Le plus simple pourrait être l'ajout dans custom.cfg d'une ligne
glob_options="locale=fr_FR bootkbd=fr console-setup/layoutcode=fr console-setup/variantcode=oss"
et d'ajouter à la fin de chaque ligne "linux" ou "linux16" du fichier loopback.cfg

${glob_options}

Enfin, Babdu89 avait trouvé une faille dans certaines distributions lorsque le chemin d'accès au fichier iso, ou le nom du fichier iso contient des espaces (tabulations ?). Cette faille résulte d'erreurs non pas du script, mais de la distribution elle-même, dans laquelle il manque l'encadrement de variables par une paire de ". J'avais prévu de créer un lien physique à la racine de la partition dans laquelle se trouve le fichier, caché, de nom identique à l'inode du fichier iso (ce qui en garantit l'unicité et l'absence de caractères susceptibles de perturber le démarrage de la distribution).

---

Arbiel Perlacremaz
LDLC Aurore NK3S-8-S4 Ubuntu 20.04, GNOME 3.36.8
24.04 en cours de tests
Abandon d'azerty au profit de bépo, de google au profit de Lilo et de la messagerie électronique violable au profit de Protonmail, une messagerie chiffrée de poste de travail à poste de travail.

Babdu89

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

Je continue les tests.
Les iso Ubuntu et ses dérivé officiels démarrent des sessions live.
La Mint 17 marche. le MultiSystem 12.04 (ms_lts_precise_r7.iso) marche.

Quelque soit l'endroit du stockage des iso (hdd interne, hdd usb,clé usb)  sans être obligatoirement dans la racine des partitions de stockage.
Pour les chemins d'accès , pas de noms de répertoires, dossiers et sous dossiers avec des espaces entre les caractères. Sinon çà ne marche pas.

La vieille 8.04.3 ne marche pas (version de grub incompatible).
Zorin-6  ne marche pas.

J'ai tenté le lancement d'iso de mes systèmes installés faites avec Remartersys.
Je n'ai pas de message d'erreurs dans le terminal. le fichier ... .loopback.cfg  est bien créé.
J'ai les entrées dans le fichier  custom.cfg . Au redémarrage j'ai le bon affichage au menu grub .  Mais çà ne charge pas ces iso . (Dommage j'en ai fait un paquet) .
Çà reste comme çà; écran vide sans rien faire, j'ai laissé un bon quart d'heure pour voir.

J'ai testé sans succès  ; handylinux, bodhi-liux,  slitaz , tails,
Les iso "techniques"  clonezilla usb, super grub et supergrub2 , system recue cd .

Je vais tester  Voyager 14.04 .
Édit;
Çà marche, je poste depuis. Belle réalisation cette distro .

@+.  Babdu89  .

Dernière modification par Babdu89 (Le 18/05/2015, à 22:20)

---

J'ai découvert Ubuntu avec la 07.10.... Et alors?!...  Depuis je regarde de temps en temps si Windows marche toujours....

Laërte

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

Clonezilla ne marche pas ?
J'avais vu une page du wiki qui expliquait quoi mettre dans le fichier loopback, faudrait que je la retrouve et que j'adapte mon script...

@Arbiel
J'ai bien compris le problème, je retourne me prendre la tête avec les signaux Qt et le module subprocess pour empêcher l'accès à l'option temporaire quand le système de fichier du dossier grub sélectionné n'est pas compatible (ou qu'il est sur LVM).

Je n'aime pas trop utiliser ce genre de méthode, mais je n'ai rien trouvé qui me permette de créer une petite fonction me donnant le type de système de fichier tout en python (si je peux limiter subprocess je suis content).

Je travaille aussi sur un moyen d'éditer le fichier custom plus en profondeur (suppression et modification d'entrées existantes). Je le mettrais en ligne quand ce sera près, pour l'instant j'ai les bases mais c'est tout, c'est encore à peaufiner.

Pour les chemins d'accès , pas de noms de répertoires, dossiers et sous dossiers avec des espaces entre les caractères. Sinon çà ne marche pas.

Concrètement s'il y a un espace dans le chemin menant au dossier où est monté le système de fichier, ça pose pas de problème. La dernière version du script affiche un message quand il y a des espaces qui posent problème.
Éventuellement s'il y en a, faire comme le proposait Arbiel, à savoir créer un lien symbolique menant à l'iso. Il y a des fonctions pour ça en python normalement, ça devrait pas être trop compliqué.

Babdu89

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

Concrètement s'il y a un espace dans le chemin menant au dossier où est monté le système de fichier, ça pose pas de problème. La dernière version du script affiche un message quand il y a des espaces qui posent problème.

Oui, je sais , j'ai vu çà avec une de mes clé usb, le message est écrit en rouge. J'ai modifié les noms des dossiers en cause, et çà a fonctionné.

Pour Clonezilla, il faudrait que je télécharge la dernière version pour l'usb, pour voir comment çà passe.

Au fait, pour les gens qui testent , il y a un moyen de trouver un débogage autre que ce que renvoie le terminal, car c'est succin .

@+.  Babdu9  .

---

J'ai découvert Ubuntu avec la 07.10.... Et alors?!...  Depuis je regarde de temps en temps si Windows marche toujours....

Laërte

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

Au fait, pour les gens qui testent , il y a un moyen de trouver un débogage autre que ce que renvoie le terminal, car c'est succin .

Il devient plus bavard quand c'est mon script qui plante. Pour la partie GRUB, comme les fichiers ne sont lus qu'au démarrage, il n'affichera d'éventuels messages d'erreur qu'à ce moment-là.
La majorité des bugs devront, je pense, être corrigés par Arbiel, puisque c'est lui qui rédige les fonctions GRUB. Concrètement, tout ce que mon script fait, c'est récupérer tes choix et écrire dans les fichiers qui vont bien.

Laërte

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

@Arbiel
C'est bon pour la vérification du système de fichier. Je n'ai pas pu tester, mon grub est sur une partition ext2 sans LVM.
Normalement, le bouton "Permanent" devrait être coché et grisé lorsque le répertoire en question est sélectionné.

J'attends les retour de bugs. (Qui seront nombreux, n'en doutons pas ^^)

Arbiel

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

Je vais essayer de prendre du temps pour tester les cas tordus (LVM, systèmes de fichiers sur lesquels grub ne sait pas écrire)

Je viens de faire un tour sur le site dont Laërte donne la référence en #59.  Je ne crois pas que grubEnhancer soit un bon nom. Ton script n'améliore pas grub, ce que ce nom suggère. Je pense qu'il est préférable de suggérer la réalité par un terme qui contienne boot et iso.

Je m'interroge sur la nécessité de la sélection du répertoire grub. Je l'ai imaginé au départ pour mes propres besoins mais je crains que cette sélection ne soit un peu complexe pour quiconque n'a pas complètement assimilé la procédure de démarrage.

Et cela d'autant plus que dans la plupart des cas, il s'agit de /boot/grub.

Ne serait-il pas plus simple de toujours viser /boot/grub et de laisser les utilisateurs les plus expérimentés passer les deux ou trois commandes qui permettent de faire pointer /boot/grub vers le bon répertoire (avec, par exemple un "sudo --bind <répertoire utilisé au démarrage> /boot/grub").

Quite à donner des indications dans le fichier readme. De toutes façons, je pense qu'il convient de donner des explications sur la méthode utilisée pour permettre aux utilisateurs de bien comprendre ce qui est une exécution permanente ou temporaire, et comment renseigner les zones des dialogues (je ne les ai pas encore vus).

Il serait aussi intéressant, me semble-t-il, de prévoir l'exécution d'un fichier iso par le simple "glisser-déposer" sur un lanceur.

Qu'en pensez-vous ?

Arbiel

Dernière modification par Arbiel (Le 19/05/2015, à 16:36)

---

Arbiel Perlacremaz
LDLC Aurore NK3S-8-S4 Ubuntu 20.04, GNOME 3.36.8
24.04 en cours de tests
Abandon d'azerty au profit de bépo, de google au profit de Lilo et de la messagerie électronique violable au profit de Protonmail, une messagerie chiffrée de poste de travail à poste de travail.

Laërte

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

Je m'interroge sur la nécessité de la sélection du répertoire grub. Je l'ai imaginé au départ pour mes propres besoins mais je crains que cette sélection ne soit un peu complexe pour quiconque n'a pas complètement assimilé la procédure de démarrage.

Et cela d'autant plus que dans la plupart des cas, il s'agit de /boot/grub.

Dans les dernières versions, /boot/grub est sélectionné par défaut (si /boot/grub/grub.cfg existe bien sûr )
On peut faire un sudo --bind sur un répertoire déjà remplit ?

Personnellement je préfère laisser le choix de sélection du répertoire GRUB. Pour ceux qui ont au moins deux répertoires grub à modifier (comme moi avec ma clef USB), ça simplifie les choses.

Pour le fichier README, je suis totalement d'accord. Je ne sais pas si tu as déjà lu celui que j'ai fait, mais il est certainement améliorable, ne serait-ce qu'au niveau des explications du fonctionnement (je suis pas toujours très clair... )

Pour le glisser-déposer, ça me paraît compliqué : comment préciser un fichier loopback, ou ne serait-ce que le paramètre temporaire/permanent ? Si tu as des idées, par contre, c'est faisable normalement.

Pour le nom du programme, je l'ai mis à l'arrache parce qu'il fallait que je nomme mon dossier. Je suis prêt à en discuter, si vous avez des idées.

En parlant d'idées, si vous voyer un truc à améliorer, au niveau ergonomie ou n'importe quoi, dîtes-le, je m'arracherai les cheveux sur votre idée .

Babdu89

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

Bonjour.

Arbiel a écrit :

    Je m'interroge sur la nécessité de la sélection du répertoire grub. Je l'ai imaginé au départ pour mes propres besoins mais je crains que cette sélection ne soit un peu complexe pour quiconque n'a pas complètement assimilé la procédure de démarrage.

    Et cela d'autant plus que dans la plupart des cas, il s'agit de /boot/grub.

Dans les cas d'installations mono Os , çà ne pose pas de problème. Il n'y a possibilité d'utiliser que le /boot/grub du seul Os de la machine.

Dans le cas d'installations multi disques multi Os.
Si le script est installé sur un Os qui est démarré depuis le menu grub d'un autre Os. Si on ne veut pas changer le mode de démarrage.
Il faut bien pouvoir écrire le boot (greffon et custom.cfg) dans le /boot/grub   de l'Os qui démarre la machine. Non?.
Dans ce cas il faut monter la partition système de cet Os.
C'est ce que je fais chez moi...

J'ai même réussi à utiliser le /boot/grub d'une clé Multisystem avec le script de Arbiel. Puisque le MultiSystem utilise grub pour booter.
Il faudrait que je retente avec le script en python pour voir. Vais faire çà tout à l'heure j'ai une clé MultiSystem disponible sans iso dessus...

Remarque
Lorsque l'on lance les scripts. Dans le cas de machines multi boot multi disques.
Si la machine est démarre directement sur l'Os qui lance le script.
Il n'y a pas intérêt à monter les partitions systèmes des autres Os de la config.
Il vaut mieux même les démonter. Sinon, on ne s'y retrouve plus.
Il faut que je teste encore çà, pour voir ce qui est proposé dans le cadre des répertoire grub.

@+.   Babdu89  .

---

J'ai découvert Ubuntu avec la 07.10.... Et alors?!...  Depuis je regarde de temps en temps si Windows marche toujours....

Laërte

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

Pour l'affichage des 4 lignes "Essayer …", "Installer …", …, le script affiche les instructions pour grub intégrées dans le fichier iso, qu'il est aisé de traduire en français. Par contre, le problème est beaucoup plus important lorsque grub n'est pas le lanceur utilisé dans l'image iso, et je ne sais pas le résoudre facilement. C'est d'ailleurs la raison pour laquelle je n'ai pas encore trouvé comment amorcer Manjaro.

J'ai réussi à amorcer Manjaro (mais juste amorcer, ça plante lors du chargement de l'OS).

Fichier live.cfg (contenu dans liso):

label start
  kernel /manjaro/boot/x86_64/manjaroiso
  append initrd=/manjaro/boot/x86_64/manjaro.img misobasedir=manjaro misolabel=MJRO0811 nouveau.modeset=1 i915.modeset=1 radeon.modeset=1 logo.nologo overlay=free quiet splash showopts

Équivalent en loopback :

menuentry "Booter en 64 bits" {
	linux /manjaro/boot/x86_64/manjaroiso misolabel=MJRO0811 nouveau.modeset=1 i915.modeset=1 radeon.modeset=1 logo.nologo overlay=free quiet splash showopts
	initrd /manjaro/boot/x86_64/manjaro.img
}

Le problème vient à mon avis du fait que je n'ai pas trouvé l'équivalent GRUB de misobasedir=manjaro (manjaro est un dossier à la racine de l'iso).
Si ça peut aider quelqu'un à trouver une solution...

lynn

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

Bonjour,

.../...
Ce n'est pas le cas avec ce qui est expliqué dans la doc, il faut stocker les iso à la racine de la partition système de L'Os qui lance le script.
.../...

.../...
les isos sont stockés à la racine de cette partition plutôt que dans un sous-dossier car plus facile à trouver pour grub.
.../...

C'était peut-être vrai il y'a un moment; Ça fait bien longtemps que j'amorce des fichiers iso situés sur une autre partition en me servant du fichier 40_custom.

Exemple clonezilla:

menuentry "Clonezilla live" {
search --no-floppy --fs-uuid --set fa4f07bb-718d-47be-bebc-c602a6575d7d
set isofile="/clonezilla-live-2.4.1-19-amd64.iso"
loopback loop $isofile
linux (loop)/live/vmlinuz boot=live username=user config ocs_numlk=on ocs_live_batch=no vga=791 components noswap edd=on nodmraid noeject locales=fr_FR.UTF-8 keyboard-layouts=fr  ip=frommedia nosplash toram=filesystem.squashfs findiso=$isofile
initrd (loop)/live/initrd.img
}

N.B: Depuis les versions 2.4.* de clonezilla, je rajoute systématiquement "username=user" dans les options sinon ça ne démarre pas. Ça plante juste avant que n'arrive l'interface semi-graphique...

@Laerte
Bon courage pour la suite de ton logiciel.

---

«C'est pas parce qu'ils sont nombreux à avoir tort qu'ils ont raison!»

Coluche