Quali comandi sono disponibili nella sezione %pre di un file Kickstart su CentOS?

Il %pre sezione(i) del tuo kickstart eseguito all'interno dell'ambiente di installazione .

Ecco un elenco di comandi utili disponibili nell'ambiente di installazione in RHEL6.5:

• Utilità 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
• Editori e cercapersone:less more vi
• Utilità hash:md5sum sha1sum sha256sum
• Compressione e archiviazione:gzip bzip2 cpio dd tar rpm
• fsck /mkfs /eccetera. per ext2 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à del disco:eject dump restore hdparm smartctl losetup kpartx parted fdisk sfdisk
• Gestione/finestre di dialogo della console:chvt consolehelper openvt whiptail zenity
• Registrazione:logger rsyslogd syslogd
• python
• E molto altro!

Se esegui un'installazione manuale, puoi passare al terminale su VT2 (Ctrl Alt F2 ) 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 in /sys sono disponibili molte informazioni di sistema e /proc .

(E sì, il kickstart viene analizzato nuovamente dopo il %pre gli script vengono eseguiti, quindi il tuo %pre può modificare il kickstart e/o generare nuovi frammenti kickstart da usare con %include .)

Comandi come questi in genere non sono disponibili nel %pre sezione di kickstart.

estratto - http://narrabilis.com/book/export/s5/6

%pre

La sezione %pre è dove puoi specificare i comandi da eseguire prima che il sistema sia installato. I comandi inseriti qui non vengono eseguiti nell'ambiente di installazione chroot. %pre deve trovarsi alla fine del file kickstart. Puoi aggiungere --interpreter al %pre in modo che lo script pre esegua un interprete diverso da /bin/sh

La documentazione di Fedora discute anche di ciò che è disponibile in %pre , nella sezione Capitolo 4. Script di pre-installazione dei documenti di Anaconda/Kickstart.

estratto

Puoi aggiungere comandi da eseguire sul sistema subito dopo che 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. Puoi accedere alla rete nella sezione %pre; tuttavia, il servizio dei nomi non è stato configurato a questo punto, quindi funzioneranno solo gli indirizzi IP.

Finalmente i documenti ufficiali di Red Hat hanno questo da dire, intitolato:32.6. Script di preinstallazione:

La sezione dello script di pre-installazione 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 pre-installazione si verifica durante la seconda fase del processo di installazione.

Quindi avrai accesso ai comandi inclusi nel tuo interprete (Bash, Python, ecc.) ma poco altro.

Dopo aver scavato un po' di più, ho trovato un sacco di informazioni di sistema in /proc che è disponibile per la visualizzazione quando %pre sezione in ks.cfg esegue. Controlla dmidecode e file in /proc per ottenere tutte le informazioni di cui hai bisogno. 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_sizes=""
  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="0\s+([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 id\s+: ([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 cores\s+: ([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 <enter> 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 più informazioni... Puoi anche fare quanto 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