È fondamentale capire bene il codice prima di adattarlo al tuo progetto e se hai qualcosa da contribuire puoi dirlo nei commenti.
Soluzione:
Il %pre dell'esecuzione del kickstart all'interno dell'ambiente di installazione.
Ecco un elenco di comandi utili disponibili nell'ambiente dell'installatore in RHEL6.5:
- Utilità della shell:
arch awk basename bash cat chattr chgrp chmod chown chroot clear clock consoletype cp cut date df dmesg du echo egrep env expr false fgrep find getopt grep head hwclock id kill killall killall5 less ln ls lsattr mkdir mknod mktemp mv pidof ps pwd readlink rm rmdir sed sh shred sleep sort split sync tac tail tee top touch true tty uname uniq wc which xargs - Editor e cercapersone:
less more vi - Utilità Hash:
md5sum sha1sum sha256sum - Compressione e archivi:
gzip bzip2 cpio dd tar rpm fsck/mkfs/etc. perext2 ext3 ext4 xfs btrfs msdos vfat- Altre cose del filesystem:
mkswap swapon swapoff dmraid dmsetup mdadm mdmon dump restore mt lvm lvs vgs pvs ... - Utilità di rete:
arp arping curl dhclient dhclient-script ftp ifconfig hostname ip ipcalc mtr nc ping rcp rdate rlogin telnet nslookup ntpdate route rsh rsync ssh ssh-keygen sshd scp sftp wget - Informazioni sull'hardware:
biosdevname blkdeactivate blkid blockdev dmidecode lshal lspci lsscsi sginfo smartctl - Utilità disco:
eject dump restore hdparm smartctl losetup kpartx parted fdisk sfdisk - Gestione console/dialoghi:
chvt consolehelper openvt whiptail zenity - Registrazione:
logger rsyslogd syslogd python- E molto altro ancora!
Se si esegue un'installazione manuale, è possibile passare al terminale su VT2 (CtrlAltF2) e curiosare per scoprire tutto ciò che è disponibile all'interno dell'ambiente di installazione. compgen -c | sort -u è un modo semplice per elencare tutti i comandi disponibili, e ci sono molte informazioni di sistema da trovare in /sys e /proc.
(E sì, il kickstart viene ri-parsato dopo il comando %pre quindi gli script %pre può modificare il kickstart e/o generare nuovi snippet di kickstart da usare con %include.)
Comandi di questo tipo non sono tipicamente disponibili nel file %pre di kickstart.
estratto - http://narrabilis.com/book/export/s5/6
%pre
Nella sezione %pre si possono specificare i comandi da eseguire prima dell'installazione del sistema. I comandi inseriti in questa sezione non vengono eseguiti nell'ambiente di installazione chroot.
%predeve arrivare alla fine del file di avvio. È possibile aggiungere --interprete al file%preper fare in modo che il pre script esegua un interprete diverso da quello di/bin/sh
La documentazione di Fedora parla anche di ciò che è disponibile in %prenella sezione Capitolo 4. Script di preinstallazione della documentazione di Anaconda/Kickstart.
estratto
È possibile aggiungere comandi da eseguire sul sistema subito dopo che il ks.cfg è stato analizzato e le opzioni lang, keyboard e url sono state elaborate. Questa sezione deve trovarsi alla fine del file kickstart (dopo i comandi) e deve iniziare con il comando %pre. È possibile accedere alla rete nella sezione %pre; tuttavia, il servizio di nomi non è stato configurato a questo punto, quindi funzioneranno solo gli indirizzi IP.
Infine, i documenti ufficiali di Red Hat riportano questo, intitolato: 32.6. Script di pre-installazione:
La sezione dello script di preinstallazione di kickstart non può gestire più alberi di installazione o supporti di origine. Queste informazioni devono essere incluse per ogni file ks.cfg creato, poiché lo script di preinstallazione avviene durante la seconda fase del processo di installazione.
Quindi avrete accesso ai comandi inclusi nel vostro interprete (Bash, Python, ecc.) ma poco altro.
Dopo aver scavato un po' di più, ho trovato una tonnellata di informazioni sul sistema in /proc che sono disponibili per
quando l'opzione %pre in ks.cfg viene eseguita. Controllare dmidecode e i file in /proc per ottenere tutte le informazioni necessarie. Ecco cosa ha funzionato per me:
%pre --log=/tmp/ks_pre.log
#!/bin/sh
#----------------------------------------------
# echos message to console screen and a log file
#----------------------------------------------
echo_screen_n_log() {
msg=$1
# Send to console screen
(echo "$msg") >/dev/tty1
# Send to log
echo "$msg"
}
echo_screen_n_log ""
echo_screen_n_log "Analyzing Hardware..."
echo_screen_n_log ""
#----------------------------------------------
# System Memory
#----------------------------------------------
IFS=$'n'
mem_info=(`dmidecode --type memory`)
unset IFS
sys_mem_
sys_mem_banks=""
sys_tot_mem=0
cntr=0
bank_cntr=0
for i in "${mem_info[@]}"
do
# echo_screen_n_log "i: $i"
# Maximum system memory that can be placed on the motherboard
REG_EX="Maximum Capacity: (.*)$"
if [[ $i =~ $REG_EX ]]
then
sys_mem_max=${BASH_REMATCH[1]}
fi
# How many memory slots are on the motherboard
REG_EX="Number Of Devices: (.*)$"
if [[ $i =~ $REG_EX ]]
then
sys_mem_slots=${BASH_REMATCH[1]}
fi
REG_EX="^[[:space:]]+Size: (.*)$"
if [[ $i =~ $REG_EX ]]
then
sys_mem_sizes[cntr]=${BASH_REMATCH[1]}
cntr=$(( $cntr + 1 ))
fi
REG_EX="^[[:space:]]+Bank Locator: (.*)$"
if [[ $i =~ $REG_EX ]]
then
sys_mem_banks[bank_cntr]=${BASH_REMATCH[1]}
bank_cntr=$(( $bank_cntr + 1 ))
fi
done
cntr=$(( $cntr - 1 ))
echo_screen_n_log "Max system memory: $sys_mem_max"
echo_screen_n_log "Total system slots: $sys_mem_slots"
i=0
while [ $i -le $cntr ]
do
echo_screen_n_log "Memory Bank Location ${sys_mem_banks[$i]} : ${sys_mem_sizes[$i]}"
REG_EX="No Module Installed$"
if [[ ! ${sys_mem_sizes[$i]} =~ $REG_EX ]]
then
REG_EX="^([0-9]+) [A-Z][A-Z]$"
if [[ ${sys_mem_sizes[$i]} =~ $REG_EX ]]
then
sys_tot_mem=$(( $sys_tot_mem + ${BASH_REMATCH[1]} ))
fi
fi
i=$(( $i + 1 ))
done
echo_screen_n_log "System Total Memory: $sys_tot_mem MB"
#--------------------------------------------
# Get Disk size information
#--------------------------------------------
IFS=$'n'
disk_info=(`cat /proc/partitions`)
unset IFS
total_disk_space=0
type=""
# Grab from minor column starting with 0 ending in 3 letters (drive node)
REG_EX="0s+([0-9]+) [a-z][a-z][a-z]$"
for i in "${disk_info[@]}"
do
# echo_screen_n_log "i: $i"
if [[ $i =~ $REG_EX ]]
then
total_disk_space=${BASH_REMATCH[1]}
total_disk_space=$(( $total_disk_space * 1024 ))
type="GB"
div_num=1000000000
if [ "$total_disk_space" -lt $div_num ]
then
type="MB"
div_num=1000000
fi
total_disk_space=$(( $total_disk_space / $div_num ))
fi
done
echo_screen_n_log "Disk Space: $total_disk_space $type"
#-----------------------------------------------------
# Get CPU model name
#-----------------------------------------------------
cpu_grep=`grep 'model name' /proc/cpuinfo`
cpu_model_nm="Not Found!"
REG_EX="^.*: (.*)$"
if [[ $cpu_grep =~ $REG_EX ]]
then
cpu_model_nm=${BASH_REMATCH[1]}
fi
echo_screen_n_log "CPU Model: $cpu_model_nm"
#-------------------------------------------------------
# Get number of physical CPUs
#-------------------------------------------------------
IFS=$'n'
cpu_count=(`grep "physical id" /proc/cpuinfo`)
unset IFS
last_cpu_id=""
total_cpu_cnt=0
# Add up all cores of the CPU to get total MIPS
total_cpus=0
REG_EX="^physical ids+: ([0-9]+)$"
for i in "${cpu_count[@]}"
do
# echo_screen_n_log "i: $i"
if [[ $i =~ $REG_EX ]]
then
cpu_id=${BASH_REMATCH[1]}
if [ ! "$last_cpu_id" = "$cpu_id" ]
then
total_cpu_cnt=$(( $total_cpu_cnt + 1 ))
last_cpu_id=$cpu_id
fi
fi
done
echo_screen_n_log "System physical CPUs: $total_cpu_cnt"
#-------------------------------------------------------
# Get number of CPU cores
#-------------------------------------------------------
IFS=$'n'
cpu_cores=(`grep -m 1 "cpu cores" /proc/cpuinfo`)
unset IFS
total_cpu_cores=0
REG_EX="^cpu coress+: ([0-9]+)$"
for i in "${cpu_cores[@]}"
do
# echo_screen_n_log "i: $i"
if [[ $i =~ $REG_EX ]]
then
total_cpu_cores=${BASH_REMATCH[1]}
fi
done
echo_screen_n_log "CPU cores: $total_cpu_cores"
#-------------------------------------------------------
# CPU MHz
#-------------------------------------------------------
IFS=$'n'
dmi_cpu_MHz=(`dmidecode --string processor-frequency`)
unset IFS
cpu_MHz=0
REG_EX="^[0-9]+ "
for i in "${dmi_cpu_MHz[@]}"
do
# echo_screen_n_log "i: $i"
if [[ $i =~ $REG_EX ]]
then
cpu_MHz=${BASH_REMATCH[1]}
fi
done
echo_screen_n_log "CPU MHz: ${dmi_cpu_MHz:0:1}.${dmi_cpu_MHz:1:$(( ${#dmi_cpu_MHz} - 1 ))}"
#-------------------------------------------------------
# Get CPU bogomips (Millions of instructions per second)
#-------------------------------------------------------
IFS=$'n'
cpu_mips=(`grep "bogomips" /proc/cpuinfo`)
unset IFS
# Add up all cores of the CPU to get total MIPS
total_mips=0
REG_EX="s([0-9]+)..*$"
for i in "${cpu_mips[@]}"
do
# echo_screen_n_log "i: $i"
if [[ $i =~ $REG_EX ]]
then
cpu_bogomips=${BASH_REMATCH[1]}
total_mips=$(( $total_mips + $cpu_bogomips ))
fi
done
echo_screen_n_log "Total CPU MIPS (Millions of instructions per second) : $total_mips"
echo_screen_n_log ""
(echo -n "Press to continue..") >/dev/tty1
read text
%end
Devo solo aggiungere i criteri per determinare come dovrebbe essere un sistema di base per le nostre installazioni e ho finito.....
Aggiornato con ulteriori informazioni...
Si può anche fare come segue per le informazioni sul disco nella sezione %pre:
IFS=$'n'
parted_txt=(`parted -l`)
unset IFS
for i in "${parted_txt[@]}"
do
# (echo "i: "$i"") >/dev/tty1
REG_EX="^Model: (.*)$"
if [[ $i =~ $REG_EX ]]
then
disk_model=${BASH_REMATCH[1]}
# (echo "Disk Model: "$disk_model"") >/dev/tty1
fi
REG_EX="^Disk (.*): ([0-9]+).[0-9]([A-Z][A-Z])$"
if [[ $i =~ $REG_EX ]]
then
disk_device=${BASH_REMATCH[1]}
disk_capacity=${BASH_REMATCH[2]}
disk_capacity_type=${BASH_REMATCH[3]}
(echo "Device: "$disk_device" "$disk_capacity" $disk_capacity_type") >/dev/tty1
IFS=$'n'
disk_txt=(`udevadm info --query=all --name=$disk_device`)
unset IFS
is_USB_drive=0
for j in "${disk_txt[@]}"
do
#(echo "j: "$j"") >/dev/tty1
REG_EX="^ID_BUS=usb$"
if [[ $j =~ $REG_EX ]]
then
# USB keys are not to be included in total disk space
# (echo "$disk_device is a USB drive!") >/dev/tty1
is_USB_drive=1
fi
done
if [ "$is_USB_drive" = "0" ]
then
total_capacity=$(( $total_capacity + $disk_capacity ))
fi
fi
done
(echo "Disk Model: $disk_model") >/dev/tty1
(echo "Disk $disk_device Capacity: $total_capacity $disk_capacity_type") >/dev/tty1