UFFICIALE L'OT di Linux e altri OS

e_ale92 · 23 Gennaio 2018

davethecipo ha detto:
@e_ale92 pensi solo ai subvolume di BTRFS

mi hai beccato

scherzi a parte, sul gruppo telegram di archlinux it c'è un ragazzo in crisi mistica. aveva il disco collegato al pc e di colpo ha smesso di funzionare... e ora non riesce a fare nulla perché btrfs non ripristina nulla (non ho ben capito, non sto seguendo la ci vicenda)...

sento puzza di bruciato, tu? :asd:

davethecipo · 23 Gennaio 2018

Io dico che adesso arriva lele.deb a dire che quel tipo è un coglion* :asd:

e_ale92 · 23 Gennaio 2018

davethecipo ha detto:
Io dico che adesso arriva lele.deb a dire che quel tipo è un coglion* :asd:

EmanueleC · 23 Gennaio 2018

davethecipo ha detto:
Io dico che adesso arriva lele.deb a dire che quel tipo è un coglion* :asd:

cucù :rolleyes:
Sicuramente l'hard disk con dei settori danneggiati, ci sono molte modalità di ripristino su Btrfs, se i settori danneggiati non sono troppi.

e_ale92 · 24 Gennaio 2018

lele.deb ha detto:
cucù :rolleyes:
Sicuramente l'hard disk con dei settori danneggiati, ci sono molte modalità di ripristino su Btrfs, se i settori danneggiati non sono troppi.

passa ad arch e joina la community. unisciti al lato oscuro della forza :P

abcdeeeeff · 24 Gennaio 2018

Salve gente, qui c'è qualcuno che usa un client per google drive (su linux ovviamente)?
Con una ricerca veloce ho trovato solo grive e insync. Grive va fatto partire a mano, e su github dicono che è da considerarsi ancora in beta. Insync sembra ottimo, ma costa 30€ (una tantum). Conoscete qualche alternativa stabile e gratuita?
Mi serve per lavoro, quindi 30€ li pagherei anche, ma se c'è qualcosa di gratis non mi lamento. Dropbox non è un'alternativa perchè mi da troppo poco spazio gratuito (5 gb contro 17gb di drive).

EmanueleC · 24 Gennaio 2018

abcdeeeeff ha detto:
Salve gente, qui c'è qualcuno che usa un client per google drive (su linux ovviamente)?
Con una ricerca veloce ho trovato solo grive e insync. Grive va fatto partire a mano, e su github dicono che è da considerarsi ancora in beta. Insync sembra ottimo, ma costa 30€ (una tantum). Conoscete qualche alternativa stabile e gratuita?
Mi serve per lavoro, quindi 30€ li pagherei anche, ma se c'è qualcosa di gratis non mi lamento. Dropbox non è un'alternativa perchè mi da troppo poco spazio gratuito (5 gb contro 17gb di drive).

Io uso megasync che ha 50 GB freee e client nativo, ma per quel poco che uso su DRIVE, lo sincronizzo con il file manager, basta su KDE o GNOME impostare l'account online.
http://www.marcosbox.org/2017/05/integrazione-google-drive-in-kde-plasma-dolphin.html

EmanueleC · 24 Gennaio 2018

e_ale92 ha detto:
passa ad arch e joina la community. unisciti al lato oscuro della forza :P

Vedo errori IO, quindi hard disk, quel check è il primo comando basilare, meno invasivo, ci sono altri più invasivi e che a volte risolvono, poi c'è il mount con "usebackuproot":
Le varie opzioni di check:

SAFE OR ADVISORY OPTIONS

-b|--backup

use the first valid set of backup roots stored in the superblock

This can be combined with --super if some of the superblocks are damaged.

--check-data-csum

verify checksums of data blocks

This expects that the filesystem is otherwise OK, so this is basically and offline scrub but does not repair data from spare copies.

--chunk-root <bytenr>

use the given offset bytenr for the chunk tree root

-E|--subvol-extents <subvolid>

show extent state for the given subvolume

-p|--progress

indicate progress at various checking phases

-Q|--qgroup-report

verify qgroup accounting and compare against filesystem accounting

-r|--tree-root <bytenr>

use the given offset bytenr for the tree root

--readonly

(default) run in read-only mode, this option exists to calm potential panic when users are going to run the checker

-s|--super <superblock>

use 'superblock’th superblock copy, valid values are 0, 1 or 2 if the respective superblock offset is within the device size

This can be used to use a different starting point if some of the primary superblock is damaged.

--clear-space-cache v1|v2

completely wipe all free space cache of given type

For free space cache v1, the clear_cache kernel mount option only rebuilds the free space cache for block groups that are modified while the filesystem is mounted with that option. Thus, using this option with v1 makes it possible to actually clear the entire free space cache.

For free space cache v2, the clear_cache kernel mount option does destroy the entire free space cache. This option with v2 provides an alternative method of clearing the free space cache that doesn’t require mounting the filesystem.

DANGEROUS OPTIONS

--repair

enable the repair mode and attempt to fix problems where possible

--init-csum-tree

create a new checksum tree and recalculate checksums in all files

Note: Do not blindly use this option to fix checksum mismatch problems.

--init-extent-tree

build the extent tree from scratch

Note: Do not use unless you know what you’re doing.

--mode=MODE

select mode of operation regarding memory and IO

The MODE can be one of original and lowmem. The original mode is mostly unoptimized regarding memory consumption and can lead to out-of-memory conditions on large filesystems. The possible workaround is to export the block device over network to a machine with enough memory. The low memory mode is supposed to address the memory consumption, at the cost of increased IO when it needs to re-read blocks when needed. This may increase run time.

Note: lowmem mode does not work with --repair yet, and is still considered experimental.

--force

allow to work on a mounted filesystem. Note that this should work fine on a quiescent or read-only mounted filesystem but may crash if the device is changed externally, eg. by the kernel module. Repair without mount checks is not supported right now.

L'opzione di mount usebackuproot, che è quella che proverei a fare:

usebackuproot
nousebackuproot

Enable autorecovery attempts if a bad tree root is found at mount time. Currently this scans a backup list of several previous tree roots and tries to use the first readable. This can be used with read-only mounts as well.

Note: This option has replaced recovery.

EmanueleC · 24 Gennaio 2018

Ho trovato anche altre opzioni/guide, ma deve fare le procedure uno ad uno, iniziando da quella meno invadente ad arrivare a quella più invadente e sua responsabilità se perde i dati con un comando errato:
https://btrfs.wiki.kernel.org/index.php/Restore

Guida (non so la data di pubblicazione):

Recovering from filesystem corruption in btrfs
In cases where the physical disk has not failed but instead something in the btrfs journal or checksum trees is corrupted and does not match, and the filesystem refuses to mount, this is the recommended procedure to try:

First make a backup the volume.

After that try to mount the volume in the read-only recovery mode:

$ mount -t btrfs -o ro,usebackuproot /dev/sda2 /home
If that fails, look in syslog (or run dmesg) and look for btrfs errors:

[ 74.926506] Btrfs loaded
[ 74.927393] BTRFS: device fsid 4e90ec15-e6f5-470d-96be-677f654a5c79 devid 2 transid 691061 /dev/sdc1
[ 77.439765] BTRFS info (device sdc1): disk space caching is enabled
[ 77.440620] BTRFS: failed to read the system array on sdc1
If there are messages relating to the log tree (not in the example above), then reset the log tree by running:

$ btrfs-zero-log
If syslog shows problems regarding the chunk tree, then btrfs rescue chunk-recover may be of used to replace the chunk blocks with new ones that should work (but may loose some data). Each disk has multiple copies of super blocks, and they are very unlikely to all get corrupted at the same time, but it happens they can be recovered with the rescue command:

$ btrfs rescue super-recover -v /dev/sde1
All Devices:
Device: id = 3, name = /dev/sdc1
Device: id = 1, name = /dev/sda2
Device: id = 2, name = /dev/sde1

Before Recovering:
[All good supers]:
device name = /dev/sdc1
superblock bytenr = 65536

device name = /dev/sdc1
superblock bytenr = 67108864

device name = /dev/sdc1
superblock bytenr = 274877906944

device name = /dev/sda2
superblock bytenr = 65536

device name = /dev/sda2
superblock bytenr = 67108864

device name = /dev/sda2
superblock bytenr = 274877906944

[All bad supers]:
device name = /dev/sde1
superblock bytenr = 65536

device name = /dev/sde1
superblock bytenr = 67108864

device name = /dev/sde1
superblock bytenr = 274877906944

After those, try btrfsck, and possibly with options -s1, -s2, -s3. It the volume is still not mountable, then try btrfsck --repair.

The command btrfsck --repair --init-extent-tree may be necessary if the extent tree was corrupted. If there is corruption in the checksums, try –init-csum-tree.

Last resort is to run btrfs check --repair but it’s not recommended because it might write changes to the disk that destroys data.

Generic tools might also be useful. For example the tool testdisk is able to scan disks and find lost partition tables, including ones with btrfs partitions.

Restoring files from a broken btrfs filesystem
If it simply is impossible to mount a btrfs filesystem, it is possible to use the command btrfs restore to fetch files from withing a damaged btrfs partition. The default command will get all files from the root volume.

Sometimes simply restore isn’t enough. For example in Ubuntu, by default the /home directory is a separate btrfs subvolume. To fetch files from there the correct volume root must be defined via the -r option. Also you might not be interested in restoring all possible files, maybe just one particular directory, and for such use a filename filter can be defined with the --path-regex option.

To fetch all files from /home/otto/Kuvat on a system there the @home subvolume object id is 258, the task can be accomplished with the command:

$ btrfs restore -i -vvvv -r 258 --path-regex "^/(otto(|/Kuvat(|/.*)))$" /dev/sdc1 .
...
Restoring ./otto/Kuvat/2015/08/09/IMG_2888.JPG
Restoring ./otto/Kuvat/2015/08/09/IMG_2889.JPG
Restoring ./otto/Kuvat/2015/08/09/IMG_2890.JPG
Restoring ./otto/Kuvat/2015/08/09/IMG_2891.JPG
Restoring ./otto/Kuvat/2015/08/09/IMG_2892.JPG
Restoring ./otto/Kuvat/2015/08/09/IMG_2893.JPG
Found objectid=18094703, key=18094702
Done searching /otto/Kuvat/2015/08/09
Found objectid=18094632, key=18094631
Done searching /otto/Kuvat/2015/08
Found objectid=8304076, key=8304075
Done searching /otto/Kuvat/2015
Found objectid=272, key=271
Done searching /otto/Kuvat
Found objectid=258, key=257
Done searching /otto
Found objectid=257, key=256
Done searching
Detecting data corruption
If btrfs detects errors, they will be logged to syslog. Btrfs also maintains error counters, which on normal healthy drives should always list all zeros:

$ btrfs device stats /mnt
[/dev/sda2].write_io_errs 0
[/dev/sda2].read_io_errs 0
[/dev/sda2].flush_io_errs 0
[/dev/sda2].corruption_errs 0
[/dev/sda2].generation_errs 0
[/dev/sdc1].write_io_errs 0
[/dev/sdc1].read_io_errs 0
[/dev/sdc1].flush_io_errs 0
[/dev/sdc1].corruption_errs 0
[/dev/sdc1].generation_errs 0
Btrfs automatically calculates CRC-32C checksums for both data and metadata blocks, and at regular intervals checks if the checksums still match or not. If data corruption is detected, then btrfs will log errors to syslog. If RAID 1 is enabled, btrfs will also automatically fix the corrupted data by overwriting with by the correct duplicate. This process can also be automatically triggered by running btrfs scrub.

Checking disk health
Disks that support the SMART standard are able to report their health status. The Gnome tool ‘disks’ provides a very easy way to access SMART data. Just open Disks, select a device and choose ‘Show SMART Data & Self-Tests’.

rebellion · 24 Gennaio 2018

davethecipo ha detto:
Dunque per ora li evito.

ti dai alla panificazione? (scusa non ho saputo resistere!:lol:)

@e_ale92 alùra, versione 4.6-4, mi manca solo di fare la parte operativa dell'installazione, prova un po'tutte le funzionalità e vedi che ne pensi e se ci metteresti qualcosa:

Codice:

#!/bin/bash
###################################################################################################################
# aur-update v4.6-4
# Script di aggiornamento pacchetti installati da AUR, by rebellion
# Da lanciare tramite terminale per visualizzare messaggi di dialogo con lo script
# a es.: gnome-terminal --geometry 75x25 --hide-menubar --title="AUR update" -e 'sh -c "sh /home/$USER/aur-update"'
# Per il manuale d'uso digitare: sh aur-update -h
# Gli aggiornamenti sono organizzati in ~/.cache/AUR/$nomepacchetto dove sono presenti PKGBUILD, pkg compilato
#  e lo snapshot scaricato .tar.gz
###################################################################################################################
controllo_dipendenze () {
   check_dip_aur="ok" ; a="\"Depends\"" ; aa="\",\""
   dipendenze=$(curl -s "https://aur.archlinux.org/rpc.php?v=5&type=info&arg=$package_name")
   make_dip=${dipendenze##*MakeDepends} ; if [ "$make_dip" = "$dipendenze" ] ; then make_dip="nessuna" ; else make_dip=${make_dip%%]*} ; make_dip=${make_dip:4} ; make_dip=${make_dip:0: -1} ; make_dip=${make_dip//$aa/ } ; fi
   main_dip=${dipendenze##*$a} ; if [ "$main_dip" = "$dipendenze" ] ; then main_dip="nessuna" ; else main_dip=${main_dip%%]*} ; main_dip=${main_dip:3} ; main_dip=${main_dip:0: -1} ; main_dip=${main_dip//$aa/ } ; fi
   opt_dip=${dipendenze##*OptDepends} ; if [ "$opt_dip" = "$dipendenze" ] ; then opt_dip="nessuna" ; else opt_dip=${opt_dip%%]*} ; opt_dip=${opt_dip:4} ; opt_dip=${opt_dip:0: -1} ; opt_dip=${opt_dip//$aa/ } ; fi
   echo "DIPENDENZE:"
   if [ "$main_dip" != "nessuna" ] ; then
      numero_dipendenze=$(($(grep -o " " <<<"$main_dip" | wc -l)+1))
      for ((ii=1;ii<=$numero_dipendenze;ii++)) ; do dip=$(echo $main_dip | awk -v xx=$ii '{print$xx}') ; dip=${dip%%>*} ; dip=${dip%%<*} ; dip=${dip%%=*} ; if pacman -Q | grep -w "$dip" 1>/dev/null ; then dips="${LIGHT_WHITE}"$dip"${NC}-----> ${LIGHT_GREEN}installata${NC}" ; else dips="${LIGHT_WHITE}"$dip"${NC}-----> ${LIGHT_RED}non installata${NC}" ; fi
         if pacman -Si "$dip" &>/dev/null ; then dips=$dips"(${LIGHT_WHITE}community${NC})" ; else dips=$dips"(${LIGHT_WHITE}AUR${NC})" ; check_dip_aur="no" ; fi
         echo -e $dips
      done
   else echo -e "${LIGHT_WHITE}NESSUNA dipendenza richiesta.${NC}"
   fi
   echo -e "\nDIPENDENZE OPZIONALI:"
   if [ "$opt_dip" != "nessuna" ] ; then
      numero_dipendenze=$(($(grep -o " " <<<"$opt_dip" | wc -l)+1))
      for ((ii=1;ii<=$numero_dipendenze;ii++)) ; do dip=$(echo $opt_dip | awk -v xx=$ii '{print$xx}') ; dip=${dip%%>*} ; dip=${dip%%<*} ; dip=${dip%%=*} ; if pacman -Q | grep -w "$dip" 1>/dev/null ; then dips="${LIGHT_WHITE}"$dip"${NC}-----> ${LIGHT_GREEN}installata${NC}" ; else dips="${LIGHT_WHITE}"$dip"${NC}-----> ${LIGHT_RED}non installata${NC}" ; fi
         if pacman -Si "$dip" &>/dev/null ; then dips=$dips"(${LIGHT_WHITE}community)" ; else dips=$dips"(${LIGHT_WHITE}AUR${NC})" ; fi
         echo -e $dips
      done
   else echo -e "${LIGHT_WHITE}NESSUNA dipendenza opzionale richiesta.${NC}"
   fi
   echo -e "\nDIPENDENZE PER LA COMPILAZIONE (MAKE):"
   if [ "$make_dip" != "nessuna" ] ; then
      numero_dipendenze=$(($(grep -o " " <<<"$make_dip" | wc -l)+1))
      for ((ii=1;ii<=$numero_dipendenze;ii++)) ; do dip=$(echo $make_dip | awk -v xx=$ii '{print$xx}') ; dip=${dip%%>*} ; dip=${dip%%<*} ; dip=${dip%%=*} ; if pacman -Q | grep -w "$dip" 1>/dev/null ; then dips="${LIGHT_WHITE}"$dip"${NC}-----> ${LIGHT_GREEN}installata${NC}" ; else dips="${LIGHT_WHITE}"$dip"${NC}-----> ${LIGHT_RED}non installata${NC}" ; fi
         if pacman -Si "$dip" &>/dev/null ; then dips=$dips"(${LIGHT_WHITE}community${NC})" ; else dips=$dips"(${LIGHT_WHITE}AUR${NC})" ; check_dip_aur="no" ; fi
         echo -e $dips
      done
   else echo -e "${LIGHT_WHITE}NESSUNA dipendenza per la compilazione richiesta.${NC}"
   fi
   pkg="n"
   if [ -f "$package_dir/$package_name/PKGBUILD" ] ; then
      echo ; read -sp "Vuoi consultare il PKGBUILD in locale di $package_name prima di aggiornare? [s/n]" pkg
      if [ "$pkg" = "s" ] ; then clear ; echo -e "${LIGHT_WHITE}$package_dir/$package_name/PKGBUILD${NC}\n" ; cat $package_dir/$package_name/PKGBUILD ; echo ; read -sp "[Premi invio per continuare]" ; fi
   else
      echo ; echo -e "${LIGHT_WHITE}PKGBUILD${NC} in $package_dir/$package_name ${LIGHT_WHITE}assente${NC}." ; read -s -p "[Premi invio per continuare]"
   fi
}
updating () {
      risultato=""
      for ((i=1;i<=$numero;i++)) ; do
         clear
         echo -n "Controllo connessione internet..."
         if ping -q -c 1 -W 1 8.8.8.8 >/dev/null || ping -q -c 1 -W 1 google.com >/dev/null ; then
            echo -e "${LIGHT_WHITE}Connessione ok${NC}"
            package_name=$(echo $update | awk -v x=$i '{print$x}')
            echo -e "Installazione ${LIGHT_WHITE}$package_name${NC}:"
            package_name_tar=$package_name".tar.gz" ; echo -en "ricerca ${LIGHT_WHITE}$package_name_tar${NC}..."
            package_dir_del="/home/$USER/.cache/$package_name"
            package_dir="/home/$USER/.cache/AUR" ; [[ -d "$package_dir" ]] || mkdir /home/$USER/.cache/AUR
            package_path="/home/$USER/.cache/AUR/$package_name_tar" ; package_path_old=$package_path".old"
            package_dir_name="/home/$USER/.cache/AUR/$package_name"
            package_dir_name_old=$package_dir_name"_old"
            echo "fatto." ; echo -n "Ricerca versioni..."
            versione_new=$(curl -s "https://aur.archlinux.org/rpc.php?v=5&type=info&arg=$package_name" | grep "Version") ; outofdate=$(echo $versione_new | grep "OutOfDate\":null") ; [[ "$outofdate" = "" ]] && outofdate="(OutOfDate)" || outofdate=""
            versione_new=${versione_new//,/ } ; versione_new=$(echo $versione_new | awk '{print$8}') ; versione_new=${versione_new:11} ; versione_new=${versione_new:0: -1}$outofdate
            versione_old=$(pacman -Qi $package_name | grep "Versione" | awk '{print$3}')
            echo "fatto." ; echo -e "Versione installata: ${LIGHT_WHITE}$versione_old${NC}\nVersione da installare: ${LIGHT_WHITE}$versione_new${NC}"
            echo -e "\nControllo dipendenze del pacchetto ${LIGHT_WHITE}$package_name${NC}:\n"
            controllo_dipendenze
            if [ "$check_dip_aur" = "ok" ] && dialog --title "pacchetto $package_name" --backtitle "Aggiornamento AUR" --yesno "Verranno installate eventuali dipendenze mancanti presenti in community. Confermi l'aggiornamento?" 7 60 ; then clear
               [[ -d "$package_dir_name" ]] && mv $package_dir_name $package_dir_name_old
               echo -e "Aggiornamento ${LIGHT_WHITE}"$package_name"${NC} in corso, non spengere il pc o la connessione.\nbackup ${LIGHT_WHITE}"$package_dir_del"${NC}---> fatto\nbackup ${LIGHT_WHITE}"$package_name_tar"${NC}---> fatto"
               if wget -P $package_dir https://aur.archlinux.org/cgit/aur.git/snapshot/$package_name_tar ; then
                  tar -xvzf $package_dir/$package_name_tar -C $package_dir
                  read -p "Vuoi consultare il PKGBUILD scaricato? [s/n]" pkg
                  case $pkg in
                     "s")
                        if [ -e "/usr/bin/nano" ] ; then nano /home/$USER/.cache/AUR/$package_name/PKGBUILD ; else echo -e "Editor ${LIGHT_WHITE}nano${NC} non installato.\nVuoi installarlo adesso?" ; read -p "[s=si/n=no]" nan ; [[ "$nan" = "s" ]] && echo "${LIGHT_WHITE}sudo pacman -S nano..." && sudo pacman -S nano && nano /home/$USER/.cache/AUR/$package_name/PKGBUILD ; fi
                     ;;
                  esac
                  echo ; read -p "Confermi l'aggiornamento? [s/n]" pkg
                  if [ "$pkg" = "s" ] ; then
                     cd "$package_dir"/"$package_name"
                     if makepkg -s ; then
                        echo -e "Disinstallazione ${LIGHT_WHITE}$package_name${NC}" ; sudo pacman -R $package_name
                        echo -e "Installazione ${LIGHT_WHITE}$package_name${NC} scaricato" ; sudo pacman -U *.pkg.tar.xz
                        [[ -d "$package_dir_name_old" ]] && echo -en "Rimozione ${LIGHT_WHITE}$package_dir_name_old${NC} di backup..." && rm -r $package_dir_name_old && echo "fatto."
                        package_pkg=$(find /home/$USER/.cache/AUR/$package_name -type f -name "$package_name*" | grep "pkg.tar.xz") ; mv $package_pkg $package_dir
                        package_pkgbuild=$(find /home/$USER/.cache/AUR/$package_name -type f -name "$package_name*" | grep "PKGBUILD") ; mv $package_pkgbuild $package_dir
                        sudo rm -r $package_dir_name ; mkdir $package_dir/$package_name
                        package_pkg=$(find /home/$USER/.cache/AUR -type f -name "$package_name*" | grep "pkg.tar.xz") ; mv $package_pkg $package_dir_name
                        package_pkgbuild=$(find /home/$USER/.cache/AUR -type f -name "$package_name*" | grep "PKGBUILD") ; mv $package_pkg $package_dir_name
                        mv $package_dir/$package_name_tar $package_dir/$package_name
                        dialog --title "pacchetto $package_name" --backtitle "Aggiornamento AUR" --msgbox "Aggiornamento eseguito!" 7 60 ; clear ; risultato=$risultato" "${LIGHT_WHITE}$package_name${NC}"-->${LIGHT_GREEN}installato${NC}\n"
                     else
                        echo "Aggiornamento fallito."
                        echo -en "Rimozione cartella ${LIGHT_WHITE}$package_dir_name${NC} (cartella scompattata ${LIGHT_WHITE}$package_name_tar${NC} scaricato) e ripristino backup..."
                        sudo rm -r $package_dir/$package_name
                        [[ -f "$package_dir"/"$package_name_tar" ]] && rm $package_dir/$package_name_tar
                        [[ -d "$package_dir_name_old" ]] && mv $package_dir_name_old $package_dir_name
                        echo "fatto."
                        read -sp "[Premi invio per continuare]"
                        risultato=$risultato" "${LIGHT_WHITE}$package_name${NC}"-->${LIGHT_RED}non_installato_compilazione_interrotta(make)${NC}\n"
                     fi
                  else
                     risultato=$risultato" "${LIGHT_WHITE}$package_name${NC}"-->${LIGHT_RED}non_installato_per_scelta_utente${NC}\n"
                     echo -en "Rimozione cartella ${LIGHT_WHITE}$package_dir_name${NC} (cartella scompattata ${LIGHT_WHITE}$package_name_tar${NC} scaricato) e ripristino backup..."
                     rm -r $package_dir/$package_name
                     [[ -f "$package_dir"/"$package_name_tar" ]] && rm $package_dir/$package_name_tar
                     [[ -d "$package_dir_name_old" ]] && mv $package_dir_name_old $package_dir_name
                     echo "fatto." ; sleep 2
                  fi
               else
                  [[ -d "$package_dir_name_old" ]] && mv $package_dir_name_old $package_dir_name
                  [[ -f "$package_dir"/"$package_name_tar" ]] && rm $package_dir/$package_name_tar
                  dialog --title "pacchetto $package_name" --backtitle "Aggiornamento AUR" --msgbox "Aggiornamento fallito, sembra che AUR non contenga il pacchetto da aggiornare. Ripristinato il backup del pacchetto." 7 60 ; clear
                  risultato=$risultato" "${LIGHT_WHITE}$package_name${NC}"-->${LIGHT_RED}non_installato_non_presente_in_AUR${NC}\n"
               fi
            else
               [[ "$check_dip_aur" = "ok" ]] && risultato=$risultato" "$package_name"-->non_installato_per_scelta_utente\n" || risultato=$risultato" "$package_name"-->non installato per mancanza dipendenze AUR\n"
            fi
         else
            dialog --title "Controllo connessione internet" --backtitle "Aggiornamento AUR" --msgbox "Connessione assente, aggiornamento fallito. $package_name ripristinato all'ultima versione." 7 60 ; clear
            risultato=$risultato" "${LIGHT_WHITE}$package_name${NC}"-->${LIGHT_RED}non_installato_per_assenza_connessione_internet${NC}\n"
         fi
      done
      clear ; echo "Riassunto aggiornamento:" ; echo -e "\n$risultato" ; echo ; echo "[premi invio per terminare]" ; read -s -n 1
}
installer () {
   PACK_locale=$(pacman -Qi $PACK &>/dev/null)
   PACK_aur=$(curl -s "https://aur.archlinux.org/rpc.php?v=5&type=info&arg=$PACK")
   PACK_aur_check=${PACK_aur##*resultcount} ; PACK_aur_check=${PACK_aur_check:2:1}
   if [ "$PACK_locale" != "" ] ; then pacman -Qi $PACK ; read -sp "[premi invio per continuare]"
   else
      case $PACK_aur_check in
         "0")
            echo -e "${LIGHT_WHITE}$PACK${LIGHT_RED} non presente in AUR.${NC}" ; read -sp "[premi invio per continuare]" ;;
         * )
            aaaa="\"" ; stampa=$(echo $PACK_aur | grep Name) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*Name} && stampa=${stampa%%,*} && stampa=${stampa:3} && stampa=${stampa:0: -1} ; echo -e "\nNome                    : ${LIGHT_WHITE}$stampa${NC}"
             stampa=$(echo $PACK_aur | grep Version) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*Version} && stampa=${stampa%%,*} && stampa=${stampa:3} && stampa=${stampa:0: -1} ; echo -e "Versione                : ${LIGHT_WHITE}$stampa${NC}"
            stampa=$(echo $PACK_aur | grep Description) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*Description} ; stampa=${stampa%%,*} ; stampa=${stampa:3} ; stampa=${stampa:0: -2} ; echo -e "Descrizione             : ${LIGHT_WHITE}$stampa${NC}"
            aaa="\"URL\"" ; stampa=$(echo $PACK_aur | grep "$aaa") ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*$aaa} ; stampa=${stampa%%,*} ; stampa=${stampa:2} ; stampa=${stampa:0: -1} && stampa=${stampa//\\/} ; echo -e "URL                     : ${LIGHT_WHITE}${stampa// /}${NC}"
            aaa="\"Depends\"" ; stampa=$(echo $PACK_aur | grep "$aaa") ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*$aaa} && stampa=${stampa%%]*} && stampa=${stampa:2} && stampa=${stampa//,/ } ; echo -e "Dipendenze              : ${LIGHT_WHITE}${stampa//$aaaa/}${NC}"
            stampa=$(echo $PACK_aur | grep OptDepends) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*OptDepends} && stampa=${stampa%%]*} && stampa=${stampa:3} && stampa=${stampa//,/ } ; echo -e "Dipendenze Opzionali    : ${LIGHT_WHITE}${stampa//$aaaa/}${NC}"
            stampa=$(echo $PACK_aur | grep MakeDepends) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*MakeDepends} && stampa=${stampa%%]*} && stampa=${stampa:3} && stampa=${stampa//,/ } ; echo -e "Dipendenze Compilazione : ${LIGHT_WHITE}${stampa//$aaaa/}${NC}"
            stampa=$(echo $PACK_aur | grep OutOfDate) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*OutOfDate} && stampa=${stampa%%,*} && stampa=${stampa:2} ; echo -e "Flag                    : ${LIGHT_WHITE}$stampa${NC}"
            stampa=$(echo $PACK_aur | grep Maintainer) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*Maintainer} && stampa=${stampa%%,*} && stampa=${stampa:3} && stampa=${stampa:0: -1} ; echo -e "Mainteiner              : ${LIGHT_WHITE}$stampa${NC}"
            stampa=$(echo $PACK_aur | grep Conflicts) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*Conflicts} && stampa=${stampa%%]*} && stampa=${stampa:3} && stampa=${stampa//,/ } ; echo -e "Confligge               : ${LIGHT_WHITE}${stampa//$aaaa/}${NC}"
            stampa=$(echo $PACK_aur | grep Provides) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*Provides} && stampa=${stampa%%]*} && stampa=${stampa:3} && stampa=${stampa//,/ } ; echo -e "Fornisce                : ${LIGHT_WHITE}${stampa//$aaaa/}${NC}"
            stampa=$(echo $PACK_aur | grep Replaces) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*Replaces} && stampa=${stampa%%]*} && stampa=${stampa:3} && stampa=${stampa//,/ } ; echo -e "Rimpiazza               : ${LIGHT_WHITE}${stampa//$aaaa/}${NC}"
            stampa=$(echo $PACK_aur | grep License) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*License} && stampa=${stampa%%,*} && stampa=${stampa:3} && stampa=${stampa:0: -1} ; echo -e "Licenze                 : ${LIGHT_WHITE}${stampa//$aaaa}${NC}\n"
            read -n 1 -p "Vuoi installarlo? [s=si/n=no]" ins
            if [ "$ins" = "s" ] ; then
               echo -e "\nInstallazione ${LIGHT_WHITE}$PACK${NC}:"
            fi
      esac
   fi
   echo -e "installazione, ${RED_WHITE}work in progress...${NC}"
}
controllo_pacchetto () {
   quit=0 ; for i in $(pacman -Qqm) ; do if [ "$i" = "$AUR" ] ; then quit=1 ; fi ; done
   [[ $quit -eq 0 ]] && echo -e "aur-update: pacchetto '${LIGHT_WHITE}$AUR${NC}' non installato." && exit 0
}
LIGHT_RED='\033[0;31m' ; LIGHT_GREEN='\033[0;32m' ; LIGHT_WHITE='\033[1;37m' ; NC='\033[0m'
if pacman -Q dialog &>/dev/null ; then 
   if [ "$#" -lt 3 ] ; then
      if [ "$1" = "-p" ] && [ "$2" = "" ] ; then clear ; read -p "Inserisci il pacchetto da aggiornare> " AUR ; numero_AUR=1 ; controllo_pacchetto
      elif [ "$1" != "-p" ] && [ "$1" != "-i" ] && [ "$1" != "-h" ] && [ "$1" != "" ] ; then echo -e "sh aur-update: opzione '${LIGHT_WHITE}$1${NC}' non valida.\nsh aur-update: prova '${LIGHT_WHITE}-h${NC}' per help e info." ; exit 0
      elif [ "$1" = "-p" ] && [ "$2" != "" ] ; then AUR=$2 ; numero_AUR=1 ; controllo_pacchetto
      elif [ "$1" = "" ] ; then
         AUR=$(pacman -Qqm)
         numero_AUR=$(pacman -Qqm | wc -l)
      elif [ "$1" = "-i" ] ; then [[ "$2" = "" ]] && read -p "Inserisci il pacchetto AUR da installare> " PACK || PACK=$2 ; installer ; echo -e "${LIGHT_GREEN}*****aur-update terminato*****${NC}" && sleep 2 ; exit 0
      elif [ "$1" = "-h" ] ; then clear ; echo -e "MANUALE aur-update:\n\n${LIGHT_WHITE}NOME E DESCRIZIONE${NC}\n   aur-update - utility aggiornamento/installazione pacchetti AUR\n\n${LIGHT_WHITE}SINOSSI${NC}\n   ${LIGHT_WHITE}Uso${NC}\n      sh aur-update [OPZIONI] [nomepacchetto]\n\n${LIGHT_WHITE}OPZIONI\n   -p,${NC}      aggiornamento con richiesta del nomepacchetto\n\n${LIGHT_WHITE}   -p NOMEPACCHETTO,\n${NC}      aggiornamento NOMEPACCHETTO\n\n${LIGHT_WHITE}   -i,${NC}\n      installazione con richiesta del nomepacchetto\n\n${LIGHT_WHITE}   -i NOMEPACCHETTO,\n${NC}      installazione NOMEPACCHETTO\n\n\n${LIGHT_GREEN}*****SOFTWARE BY REBELLION, FREE AND WITHOUT LICENSE*****${NC}" ; exit 0
      else exit 0
      fi
   else echo -e "sh aur-update: troppi argomenti -- ${LIGHT_WHITE}$@${NC}.\nsh aur-update: prova '${LIGHT_WHITE}-h${NC}' per help e info." ; exit 0
   fi
   if [ "$(pacman -Qqm | grep -w "$AUR")" = "" ] ; then echo -e "sh aur-update: pacchetto ${LIGHT_WHITE}$AUR${NC} non trovato." ; exit 0 ; fi
   check=$(ps aux | grep "[s]udo pacman")
   if [ "$check" = "" ] ; then
      clear && echo -n "Controllo connessione internet..."
      if ping -q -c 1 -W 1 8.8.8.8 >/dev/null || ping -q -c 1 -W 1 google.com >/dev/null ; then
         echo -e "${LIGHT_WHITE}Connesso a internet.${NC}"
         echo -e "\nCONTROLLO PACCHETTI AGGIORNABILI, attendere..."
         aur=()
         aur_ok=()
         update=""
         count=1
         for ((i=0;i<$numero_AUR;i++)) ; do ii=$((i+1)) ; aur[$i]=$(echo $AUR | awk -v x=$ii '{print$x}')
            tput cuu 1 ; tput cuf 47 ; echo "[$(($i+1))/$numero_AUR]" ; tput el ; echo -e ${LIGHT_WHITE}${aur[$i]}${NC} ; tput cuu 1
            versione_new=$(curl -s "https://aur.archlinux.org/rpc.php?v=5&type=info&arg=${aur[$i]}" | grep "Version") ; outofdate=$(echo $versione_new | grep "OutOfDate\":null")
            if [ "$versione_new" != "" ] ; then
               versione_new=${versione_new//,/ } ; versione_new=$(echo $versione_new | awk '{print$8}') ; versione_new=${versione_new:11} ; versione_new=${versione_new:0: -1}
               versione_old=$(pacman -Qi ${aur[$i]} | grep "Versione" | awk '{print$3}')
               package_path=$(find /home/$USER -type f -name "${aur[$i]}.tar.gz") ; package_path=$(echo $package_path | awk '{print$1}')
               [[ $package_path != "" ]] && hash_old=$(md5sum $package_path | awk '{print$1}') || hash_old=""
               [[ $hash_old != "" ]] && hash_new=$(curl -s https://aur.archlinux.org/cgit/aur.git/snapshot/"${aur[$i]}.tar.gz" | md5sum | awk '{print$1}') || hash_new=""
               if [ "$versione_new" != "$versione_old" ] && ([ "$hash_old" != "$hash_new" ] || [ "$hash_old" = "" ]) ; then
                  if [ "$outofdate" != "" ] ; then descrizione="${LIGHT_GREEN}AGGIORNABILE${NC}" ; descr="AGGIORNABILE" ; else descrizione="${LIGHT_GREEN}AGGIORNABILE${NC}(${LIGHT_RED}OutOfDate${NC})" ; descr="AGGIORNABILE_(OutOfDate)" ; fi
                  if [ "$hash_old" = "" ] ; then descrizione=$descrizione"_firme_non_confrontabili" ; fi
                  aur_ok+=($count ${aur[$i]} off)
                  count=$(($count+1))
                  aur[$i]=${aur[$i]}" --->"$descrizione
               else if [ "$outofdate" != "" ] ; then descrizione="${LIGHT_WHITE}AGGIORNATO${NC}" ; else descrizione="${LIGHT_WHITE}AGGIORNATO${NC}(${LIGHT_RED}OutOfDate${NC})" ; fi ; aur[$i]=${aur[$i]}" --->"$descrizione
               fi
            else descrizione="${LIGHT_RED}NON PRESENTE IN AUR${NC}" ; aur[$i]=${aur[$i]}" --->"$descrizione
            fi
         done
         if [ "$aur_ok" = "" ] ; then
            dialog --title "Controllo pacchetti installati" --backtitle "Aggiornamento AUR" --msgbox "Tutti i pacchetti AUR installati sono aggiornati alla versione più recente!" 7 60
         else
            tput cuu 1 ; tput el ; echo "RISULTATO RICERCA PACCHETTI AGGIORNABILI:"
            for ((i=0;i<$numero_AUR;i++)) ; do echo -e ${aur[$i]} ; done
            [[ ${#aur_ok[@]} -eq 3 ]] && echo -e "\tt=aggiorna il pacchetto | altro=esci" || echo -e "\tt=aggiorna tutto | s=seleziona aggiornamenti | altro=esci"
            read -n 1 -s azione
            if [ "$azione" = "s" ] && [ ${#aur_ok[@]} -gt 3 ] ; then
               exec 3>&1 ; select=$(dialog --backtitle "Aggiornamento AUR" --checklist "Seleziona i pacchetti da aggiornare:" 20 70 ${#aur_ok[@]} ${aur_ok[@]} 2>&1 1>&3) ; exitcode=$? ; exec 3>&-
               for i in $select ; do update=$update" "${aur_ok[$(((3*$i)-2))]} ; done
               numero=$(grep -o " " <<<"$update" | wc -l)
               [[ "${update// /}" != "" ]] && updating
            elif [ "$azione" = "t" ] ; then numero=$((${#aur_ok[@]}/3))
               for ((i=0;i<$numero;i++)) ; do ii=$(( ($i*3)+1 )) ; update=$update" "${aur_ok[$ii]} ; done
               updating
            fi
         fi
      else
         dialog --title "Controllo connessione internet" --backtitle "Aggiornamento AUR" --msgbox "Sembra che manchi la connessione, impossibile proseguire." 7 60
      fi
   else dialog --title "Controllo gestione pacchetti (PACMAN)" --backtitle "Aggiornamento AUR" --msgbox "C'è già in esecuzione il gestore pacchetti, attenderne la fine." 7 60
   fi
else echo -e "\nsh aur-update: manca il pacchetto ${LIGHT_WHITE}dialog${NC}, vuoi installarlo (non richiede dipendenze)? [s=si/altro=no]" ; read dialogo
   case $dialogo in
      "s")
         sudo pacman -S dialog ;;
   esac
fi
clear ; echo -e "${LIGHT_GREEN}*****aur-update terminato*****${NC}" && sleep 2
exit 0

digita 'sh aur-update -h' così ti fai una panoramica. quando metti l'opzione '-i' parte l'installer ma prima ti fa vedere info sul pacchetto da installare eppoi ti cihede se installarlo (ancora manca la parte operativa).

ho deciso di non mettere finestre-terminale parenti per editare il pkgbuild e per il makepkg perchè così puoi lanciarlo anche senza DE.
poi si potrebbe mettere uno script eseguibile (es. pacmaur) in /usr/bin con l'istruzione di lancio di aur-update (che DEVE rimanere non eseguibile), in modo da digitare 'pacmaur [-i/-p/-h]'.

e_ale92 · 24 Gennaio 2018

lele.deb ha detto:
Ho trovato anche altre opzioni/guide, ma deve fare le procedure uno ad uno, iniziando da quella meno invadente ad arrivare a quella più invadente e sua responsabilità se perde i dati con un comando errato:
https://btrfs.wiki.kernel.org/index.php/Restore

Guida (non so la data di pubblicazione):

spero risolva da solo o con gli altri perché io non ho tempo di seguirlo. chissà se riesce a recuperare qualcosa xD

EDIT.

ah lele, una domanda. se volessi installare Windows in dual boot, senza scassare arch/btrfs? tieni presente che win mi serve per un paio di mesi, non dj più... poi lo piallerei senza pensarci due volte.

e_ale92 · 24 Gennaio 2018

rebellion ha detto:

ti dai alla panificazione? (scusa non ho saputo resistere!

)

@e_ale92 alùra, versione 4.6-4, mi manca solo di fare la parte operativa dell'installazione, prova un po'tutte le funzionalità e vedi che ne pensi e se ci metteresti qualcosa:

Codice:

#!/bin/bash
###################################################################################################################
# aur-update v4.6-4
# Script di aggiornamento pacchetti installati da AUR, by rebellion
# Da lanciare tramite terminale per visualizzare messaggi di dialogo con lo script
# a es.: gnome-terminal --geometry 75x25 --hide-menubar --title="AUR update" -e 'sh -c "sh /home/$USER/aur-update"'
# Per il manuale d'uso digitare: sh aur-update -h
# Gli aggiornamenti sono organizzati in ~/.cache/AUR/$nomepacchetto dove sono presenti PKGBUILD, pkg compilato
#  e lo snapshot scaricato .tar.gz
###################################################################################################################
controllo_dipendenze () {
   check_dip_aur="ok" ; a="\"Depends\"" ; aa="\",\""
   dipendenze=$(curl -s "https://aur.archlinux.org/rpc.php?v=5&type=info&arg=$package_name")
   make_dip=${dipendenze##*MakeDepends} ; if [ "$make_dip" = "$dipendenze" ] ; then make_dip="nessuna" ; else make_dip=${make_dip%%]*} ; make_dip=${make_dip:4} ; make_dip=${make_dip:0: -1} ; make_dip=${make_dip//$aa/ } ; fi
   main_dip=${dipendenze##*$a} ; if [ "$main_dip" = "$dipendenze" ] ; then main_dip="nessuna" ; else main_dip=${main_dip%%]*} ; main_dip=${main_dip:3} ; main_dip=${main_dip:0: -1} ; main_dip=${main_dip//$aa/ } ; fi
   opt_dip=${dipendenze##*OptDepends} ; if [ "$opt_dip" = "$dipendenze" ] ; then opt_dip="nessuna" ; else opt_dip=${opt_dip%%]*} ; opt_dip=${opt_dip:4} ; opt_dip=${opt_dip:0: -1} ; opt_dip=${opt_dip//$aa/ } ; fi
   echo "DIPENDENZE:"
   if [ "$main_dip" != "nessuna" ] ; then
      numero_dipendenze=$(($(grep -o " " <<<"$main_dip" | wc -l)+1))
      for ((ii=1;ii<=$numero_dipendenze;ii++)) ; do dip=$(echo $main_dip | awk -v xx=$ii '{print$xx}') ; dip=${dip%%>*} ; dip=${dip%%<*} ; dip=${dip%%=*} ; if pacman -Q | grep -w "$dip" 1>/dev/null ; then dips="${LIGHT_WHITE}"$dip"${NC}-----> ${LIGHT_GREEN}installata${NC}" ; else dips="${LIGHT_WHITE}"$dip"${NC}-----> ${LIGHT_RED}non installata${NC}" ; fi
         if pacman -Si "$dip" &>/dev/null ; then dips=$dips"(${LIGHT_WHITE}community${NC})" ; else dips=$dips"(${LIGHT_WHITE}AUR${NC})" ; check_dip_aur="no" ; fi
         echo -e $dips
      done
   else echo -e "${LIGHT_WHITE}NESSUNA dipendenza richiesta.${NC}"
   fi
   echo -e "\nDIPENDENZE OPZIONALI:"
   if [ "$opt_dip" != "nessuna" ] ; then
      numero_dipendenze=$(($(grep -o " " <<<"$opt_dip" | wc -l)+1))
      for ((ii=1;ii<=$numero_dipendenze;ii++)) ; do dip=$(echo $opt_dip | awk -v xx=$ii '{print$xx}') ; dip=${dip%%>*} ; dip=${dip%%<*} ; dip=${dip%%=*} ; if pacman -Q | grep -w "$dip" 1>/dev/null ; then dips="${LIGHT_WHITE}"$dip"${NC}-----> ${LIGHT_GREEN}installata${NC}" ; else dips="${LIGHT_WHITE}"$dip"${NC}-----> ${LIGHT_RED}non installata${NC}" ; fi
         if pacman -Si "$dip" &>/dev/null ; then dips=$dips"(${LIGHT_WHITE}community)" ; else dips=$dips"(${LIGHT_WHITE}AUR${NC})" ; fi
         echo -e $dips
      done
   else echo -e "${LIGHT_WHITE}NESSUNA dipendenza opzionale richiesta.${NC}"
   fi
   echo -e "\nDIPENDENZE PER LA COMPILAZIONE (MAKE):"
   if [ "$make_dip" != "nessuna" ] ; then
      numero_dipendenze=$(($(grep -o " " <<<"$make_dip" | wc -l)+1))
      for ((ii=1;ii<=$numero_dipendenze;ii++)) ; do dip=$(echo $make_dip | awk -v xx=$ii '{print$xx}') ; dip=${dip%%>*} ; dip=${dip%%<*} ; dip=${dip%%=*} ; if pacman -Q | grep -w "$dip" 1>/dev/null ; then dips="${LIGHT_WHITE}"$dip"${NC}-----> ${LIGHT_GREEN}installata${NC}" ; else dips="${LIGHT_WHITE}"$dip"${NC}-----> ${LIGHT_RED}non installata${NC}" ; fi
         if pacman -Si "$dip" &>/dev/null ; then dips=$dips"(${LIGHT_WHITE}community${NC})" ; else dips=$dips"(${LIGHT_WHITE}AUR${NC})" ; check_dip_aur="no" ; fi
         echo -e $dips
      done
   else echo -e "${LIGHT_WHITE}NESSUNA dipendenza per la compilazione richiesta.${NC}"
   fi
   pkg="n"
   if [ -f "$package_dir/$package_name/PKGBUILD" ] ; then
      echo ; read -sp "Vuoi consultare il PKGBUILD in locale di $package_name prima di aggiornare? [s/n]" pkg
      if [ "$pkg" = "s" ] ; then clear ; echo -e "${LIGHT_WHITE}$package_dir/$package_name/PKGBUILD${NC}\n" ; cat $package_dir/$package_name/PKGBUILD ; echo ; read -sp "[Premi invio per continuare]" ; fi
   else
      echo ; echo -e "${LIGHT_WHITE}PKGBUILD${NC} in $package_dir/$package_name ${LIGHT_WHITE}assente${NC}." ; read -s -p "[Premi invio per continuare]"
   fi
}
updating () {
      risultato=""
      for ((i=1;i<=$numero;i++)) ; do
         clear
         echo -n "Controllo connessione internet..."
         if ping -q -c 1 -W 1 8.8.8.8 >/dev/null || ping -q -c 1 -W 1 google.com >/dev/null ; then
            echo -e "${LIGHT_WHITE}Connessione ok${NC}"
            package_name=$(echo $update | awk -v x=$i '{print$x}')
            echo -e "Installazione ${LIGHT_WHITE}$package_name${NC}:"
            package_name_tar=$package_name".tar.gz" ; echo -en "ricerca ${LIGHT_WHITE}$package_name_tar${NC}..."
            package_dir_del="/home/$USER/.cache/$package_name"
            package_dir="/home/$USER/.cache/AUR" ; [[ -d "$package_dir" ]] || mkdir /home/$USER/.cache/AUR
            package_path="/home/$USER/.cache/AUR/$package_name_tar" ; package_path_old=$package_path".old"
            package_dir_name="/home/$USER/.cache/AUR/$package_name"
            package_dir_name_old=$package_dir_name"_old"
            echo "fatto." ; echo -n "Ricerca versioni..."
            versione_new=$(curl -s "https://aur.archlinux.org/rpc.php?v=5&type=info&arg=$package_name" | grep "Version") ; outofdate=$(echo $versione_new | grep "OutOfDate\":null") ; [[ "$outofdate" = "" ]] && outofdate="(OutOfDate)" || outofdate=""
            versione_new=${versione_new//,/ } ; versione_new=$(echo $versione_new | awk '{print$8}') ; versione_new=${versione_new:11} ; versione_new=${versione_new:0: -1}$outofdate
            versione_old=$(pacman -Qi $package_name | grep "Versione" | awk '{print$3}')
            echo "fatto." ; echo -e "Versione installata: ${LIGHT_WHITE}$versione_old${NC}\nVersione da installare: ${LIGHT_WHITE}$versione_new${NC}"
            echo -e "\nControllo dipendenze del pacchetto ${LIGHT_WHITE}$package_name${NC}:\n"
            controllo_dipendenze
            if [ "$check_dip_aur" = "ok" ] && dialog --title "pacchetto $package_name" --backtitle "Aggiornamento AUR" --yesno "Verranno installate eventuali dipendenze mancanti presenti in community. Confermi l'aggiornamento?" 7 60 ; then clear
               [[ -d "$package_dir_name" ]] && mv $package_dir_name $package_dir_name_old
               echo -e "Aggiornamento ${LIGHT_WHITE}"$package_name"${NC} in corso, non spengere il pc o la connessione.\nbackup ${LIGHT_WHITE}"$package_dir_del"${NC}---> fatto\nbackup ${LIGHT_WHITE}"$package_name_tar"${NC}---> fatto"
               if wget -P $package_dir https://aur.archlinux.org/cgit/aur.git/snapshot/$package_name_tar ; then
                  tar -xvzf $package_dir/$package_name_tar -C $package_dir
                  read -p "Vuoi consultare il PKGBUILD scaricato? [s/n]" pkg
                  case $pkg in
                     "s")
                        if [ -e "/usr/bin/nano" ] ; then nano /home/$USER/.cache/AUR/$package_name/PKGBUILD ; else echo -e "Editor ${LIGHT_WHITE}nano${NC} non installato.\nVuoi installarlo adesso?" ; read -p "[s=si/n=no]" nan ; [[ "$nan" = "s" ]] && echo "${LIGHT_WHITE}sudo pacman -S nano..." && sudo pacman -S nano && nano /home/$USER/.cache/AUR/$package_name/PKGBUILD ; fi
                     ;;
                  esac
                  echo ; read -p "Confermi l'aggiornamento? [s/n]" pkg
                  if [ "$pkg" = "s" ] ; then
                     cd "$package_dir"/"$package_name"
                     if makepkg -s ; then
                        echo -e "Disinstallazione ${LIGHT_WHITE}$package_name${NC}" ; sudo pacman -R $package_name
                        echo -e "Installazione ${LIGHT_WHITE}$package_name${NC} scaricato" ; sudo pacman -U *.pkg.tar.xz
                        [[ -d "$package_dir_name_old" ]] && echo -en "Rimozione ${LIGHT_WHITE}$package_dir_name_old${NC} di backup..." && rm -r $package_dir_name_old && echo "fatto."
                        package_pkg=$(find /home/$USER/.cache/AUR/$package_name -type f -name "$package_name*" | grep "pkg.tar.xz") ; mv $package_pkg $package_dir
                        package_pkgbuild=$(find /home/$USER/.cache/AUR/$package_name -type f -name "$package_name*" | grep "PKGBUILD") ; mv $package_pkgbuild $package_dir
                        sudo rm -r $package_dir_name ; mkdir $package_dir/$package_name
                        package_pkg=$(find /home/$USER/.cache/AUR -type f -name "$package_name*" | grep "pkg.tar.xz") ; mv $package_pkg $package_dir_name
                        package_pkgbuild=$(find /home/$USER/.cache/AUR -type f -name "$package_name*" | grep "PKGBUILD") ; mv $package_pkg $package_dir_name
                        mv $package_dir/$package_name_tar $package_dir/$package_name
                        dialog --title "pacchetto $package_name" --backtitle "Aggiornamento AUR" --msgbox "Aggiornamento eseguito!" 7 60 ; clear ; risultato=$risultato" "${LIGHT_WHITE}$package_name${NC}"-->${LIGHT_GREEN}installato${NC}\n"
                     else
                        echo "Aggiornamento fallito."
                        echo -en "Rimozione cartella ${LIGHT_WHITE}$package_dir_name${NC} (cartella scompattata ${LIGHT_WHITE}$package_name_tar${NC} scaricato) e ripristino backup..."
                        sudo rm -r $package_dir/$package_name
                        [[ -f "$package_dir"/"$package_name_tar" ]] && rm $package_dir/$package_name_tar
                        [[ -d "$package_dir_name_old" ]] && mv $package_dir_name_old $package_dir_name
                        echo "fatto."
                        read -sp "[Premi invio per continuare]"
                        risultato=$risultato" "${LIGHT_WHITE}$package_name${NC}"-->${LIGHT_RED}non_installato_compilazione_interrotta(make)${NC}\n"
                     fi
                  else
                     risultato=$risultato" "${LIGHT_WHITE}$package_name${NC}"-->${LIGHT_RED}non_installato_per_scelta_utente${NC}\n"
                     echo -en "Rimozione cartella ${LIGHT_WHITE}$package_dir_name${NC} (cartella scompattata ${LIGHT_WHITE}$package_name_tar${NC} scaricato) e ripristino backup..."
                     rm -r $package_dir/$package_name
                     [[ -f "$package_dir"/"$package_name_tar" ]] && rm $package_dir/$package_name_tar
                     [[ -d "$package_dir_name_old" ]] && mv $package_dir_name_old $package_dir_name
                     echo "fatto." ; sleep 2
                  fi
               else
                  [[ -d "$package_dir_name_old" ]] && mv $package_dir_name_old $package_dir_name
                  [[ -f "$package_dir"/"$package_name_tar" ]] && rm $package_dir/$package_name_tar
                  dialog --title "pacchetto $package_name" --backtitle "Aggiornamento AUR" --msgbox "Aggiornamento fallito, sembra che AUR non contenga il pacchetto da aggiornare. Ripristinato il backup del pacchetto." 7 60 ; clear
                  risultato=$risultato" "${LIGHT_WHITE}$package_name${NC}"-->${LIGHT_RED}non_installato_non_presente_in_AUR${NC}\n"
               fi
            else
               [[ "$check_dip_aur" = "ok" ]] && risultato=$risultato" "$package_name"-->non_installato_per_scelta_utente\n" || risultato=$risultato" "$package_name"-->non installato per mancanza dipendenze AUR\n"
            fi
         else
            dialog --title "Controllo connessione internet" --backtitle "Aggiornamento AUR" --msgbox "Connessione assente, aggiornamento fallito. $package_name ripristinato all'ultima versione." 7 60 ; clear
            risultato=$risultato" "${LIGHT_WHITE}$package_name${NC}"-->${LIGHT_RED}non_installato_per_assenza_connessione_internet${NC}\n"
         fi
      done
      clear ; echo "Riassunto aggiornamento:" ; echo -e "\n$risultato" ; echo ; echo "[premi invio per terminare]" ; read -s -n 1
}
installer () {
   PACK_locale=$(pacman -Qi $PACK &>/dev/null)
   PACK_aur=$(curl -s "https://aur.archlinux.org/rpc.php?v=5&type=info&arg=$PACK")
   PACK_aur_check=${PACK_aur##*resultcount} ; PACK_aur_check=${PACK_aur_check:2:1}
   if [ "$PACK_locale" != "" ] ; then pacman -Qi $PACK ; read -sp "[premi invio per continuare]"
   else
      case $PACK_aur_check in
         "0")
            echo -e "${LIGHT_WHITE}$PACK${LIGHT_RED} non presente in AUR.${NC}" ; read -sp "[premi invio per continuare]" ;;
         * )
            aaaa="\"" ; stampa=$(echo $PACK_aur | grep Name) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*Name} && stampa=${stampa%%,*} && stampa=${stampa:3} && stampa=${stampa:0: -1} ; echo -e "\nNome                    : ${LIGHT_WHITE}$stampa${NC}"
             stampa=$(echo $PACK_aur | grep Version) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*Version} && stampa=${stampa%%,*} && stampa=${stampa:3} && stampa=${stampa:0: -1} ; echo -e "Versione                : ${LIGHT_WHITE}$stampa${NC}"
            stampa=$(echo $PACK_aur | grep Description) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*Description} ; stampa=${stampa%%,*} ; stampa=${stampa:3} ; stampa=${stampa:0: -2} ; echo -e "Descrizione             : ${LIGHT_WHITE}$stampa${NC}"
            aaa="\"URL\"" ; stampa=$(echo $PACK_aur | grep "$aaa") ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*$aaa} ; stampa=${stampa%%,*} ; stampa=${stampa:2} ; stampa=${stampa:0: -1} && stampa=${stampa//\\/} ; echo -e "URL                     : ${LIGHT_WHITE}${stampa// /}${NC}"
            aaa="\"Depends\"" ; stampa=$(echo $PACK_aur | grep "$aaa") ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*$aaa} && stampa=${stampa%%]*} && stampa=${stampa:2} && stampa=${stampa//,/ } ; echo -e "Dipendenze              : ${LIGHT_WHITE}${stampa//$aaaa/}${NC}"
            stampa=$(echo $PACK_aur | grep OptDepends) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*OptDepends} && stampa=${stampa%%]*} && stampa=${stampa:3} && stampa=${stampa//,/ } ; echo -e "Dipendenze Opzionali    : ${LIGHT_WHITE}${stampa//$aaaa/}${NC}"
            stampa=$(echo $PACK_aur | grep MakeDepends) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*MakeDepends} && stampa=${stampa%%]*} && stampa=${stampa:3} && stampa=${stampa//,/ } ; echo -e "Dipendenze Compilazione : ${LIGHT_WHITE}${stampa//$aaaa/}${NC}"
            stampa=$(echo $PACK_aur | grep OutOfDate) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*OutOfDate} && stampa=${stampa%%,*} && stampa=${stampa:2} ; echo -e "Flag                    : ${LIGHT_WHITE}$stampa${NC}"
            stampa=$(echo $PACK_aur | grep Maintainer) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*Maintainer} && stampa=${stampa%%,*} && stampa=${stampa:3} && stampa=${stampa:0: -1} ; echo -e "Mainteiner              : ${LIGHT_WHITE}$stampa${NC}"
            stampa=$(echo $PACK_aur | grep Conflicts) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*Conflicts} && stampa=${stampa%%]*} && stampa=${stampa:3} && stampa=${stampa//,/ } ; echo -e "Confligge               : ${LIGHT_WHITE}${stampa//$aaaa/}${NC}"
            stampa=$(echo $PACK_aur | grep Provides) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*Provides} && stampa=${stampa%%]*} && stampa=${stampa:3} && stampa=${stampa//,/ } ; echo -e "Fornisce                : ${LIGHT_WHITE}${stampa//$aaaa/}${NC}"
            stampa=$(echo $PACK_aur | grep Replaces) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*Replaces} && stampa=${stampa%%]*} && stampa=${stampa:3} && stampa=${stampa//,/ } ; echo -e "Rimpiazza               : ${LIGHT_WHITE}${stampa//$aaaa/}${NC}"
            stampa=$(echo $PACK_aur | grep License) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*License} && stampa=${stampa%%,*} && stampa=${stampa:3} && stampa=${stampa:0: -1} ; echo -e "Licenze                 : ${LIGHT_WHITE}${stampa//$aaaa}${NC}\n"
            read -n 1 -p "Vuoi installarlo? [s=si/n=no]" ins
            if [ "$ins" = "s" ] ; then
               echo -e "\nInstallazione ${LIGHT_WHITE}$PACK${NC}:"
            fi
      esac
   fi
   echo -e "installazione, ${RED_WHITE}work in progress...${NC}"
}
controllo_pacchetto () {
   quit=0 ; for i in $(pacman -Qqm) ; do if [ "$i" = "$AUR" ] ; then quit=1 ; fi ; done
   [[ $quit -eq 0 ]] && echo -e "aur-update: pacchetto '${LIGHT_WHITE}$AUR${NC}' non installato." && exit 0
}
LIGHT_RED='\033[0;31m' ; LIGHT_GREEN='\033[0;32m' ; LIGHT_WHITE='\033[1;37m' ; NC='\033[0m'
if pacman -Q dialog &>/dev/null ; then 
   if [ "$#" -lt 3 ] ; then
      if [ "$1" = "-p" ] && [ "$2" = "" ] ; then clear ; read -p "Inserisci il pacchetto da aggiornare> " AUR ; numero_AUR=1 ; controllo_pacchetto
      elif [ "$1" != "-p" ] && [ "$1" != "-i" ] && [ "$1" != "-h" ] && [ "$1" != "" ] ; then echo -e "sh aur-update: opzione '${LIGHT_WHITE}$1${NC}' non valida.\nsh aur-update: prova '${LIGHT_WHITE}-h${NC}' per help e info." ; exit 0
      elif [ "$1" = "-p" ] && [ "$2" != "" ] ; then AUR=$2 ; numero_AUR=1 ; controllo_pacchetto
      elif [ "$1" = "" ] ; then
         AUR=$(pacman -Qqm)
         numero_AUR=$(pacman -Qqm | wc -l)
      elif [ "$1" = "-i" ] ; then [[ "$2" = "" ]] && read -p "Inserisci il pacchetto AUR da installare> " PACK || PACK=$2 ; installer ; echo -e "${LIGHT_GREEN}*****aur-update terminato*****${NC}" && sleep 2 ; exit 0
      elif [ "$1" = "-h" ] ; then clear ; echo -e "MANUALE aur-update:\n\n${LIGHT_WHITE}NOME E DESCRIZIONE${NC}\n   aur-update - utility aggiornamento/installazione pacchetti AUR\n\n${LIGHT_WHITE}SINOSSI${NC}\n   ${LIGHT_WHITE}Uso${NC}\n      sh aur-update [OPZIONI] [nomepacchetto]\n\n${LIGHT_WHITE}OPZIONI\n   -p,${NC}      aggiornamento con richiesta del nomepacchetto\n\n${LIGHT_WHITE}   -p NOMEPACCHETTO,\n${NC}      aggiornamento NOMEPACCHETTO\n\n${LIGHT_WHITE}   -i,${NC}\n      installazione con richiesta del nomepacchetto\n\n${LIGHT_WHITE}   -i NOMEPACCHETTO,\n${NC}      installazione NOMEPACCHETTO\n\n\n${LIGHT_GREEN}*****SOFTWARE BY REBELLION, FREE AND WITHOUT LICENSE*****${NC}" ; exit 0
      else exit 0
      fi
   else echo -e "sh aur-update: troppi argomenti -- ${LIGHT_WHITE}$@${NC}.\nsh aur-update: prova '${LIGHT_WHITE}-h${NC}' per help e info." ; exit 0
   fi
   if [ "$(pacman -Qqm | grep -w "$AUR")" = "" ] ; then echo -e "sh aur-update: pacchetto ${LIGHT_WHITE}$AUR${NC} non trovato." ; exit 0 ; fi
   check=$(ps aux | grep "[s]udo pacman")
   if [ "$check" = "" ] ; then
      clear && echo -n "Controllo connessione internet..."
      if ping -q -c 1 -W 1 8.8.8.8 >/dev/null || ping -q -c 1 -W 1 google.com >/dev/null ; then
         echo -e "${LIGHT_WHITE}Connesso a internet.${NC}"
         echo -e "\nCONTROLLO PACCHETTI AGGIORNABILI, attendere..."
         aur=()
         aur_ok=()
         update=""
         count=1
         for ((i=0;i<$numero_AUR;i++)) ; do ii=$((i+1)) ; aur[$i]=$(echo $AUR | awk -v x=$ii '{print$x}')
            tput cuu 1 ; tput cuf 47 ; echo "[$(($i+1))/$numero_AUR]" ; tput el ; echo -e ${LIGHT_WHITE}${aur[$i]}${NC} ; tput cuu 1
            versione_new=$(curl -s "https://aur.archlinux.org/rpc.php?v=5&type=info&arg=${aur[$i]}" | grep "Version") ; outofdate=$(echo $versione_new | grep "OutOfDate\":null")
            if [ "$versione_new" != "" ] ; then
               versione_new=${versione_new//,/ } ; versione_new=$(echo $versione_new | awk '{print$8}') ; versione_new=${versione_new:11} ; versione_new=${versione_new:0: -1}
               versione_old=$(pacman -Qi ${aur[$i]} | grep "Versione" | awk '{print$3}')
               package_path=$(find /home/$USER -type f -name "${aur[$i]}.tar.gz") ; package_path=$(echo $package_path | awk '{print$1}')
               [[ $package_path != "" ]] && hash_old=$(md5sum $package_path | awk '{print$1}') || hash_old=""
               [[ $hash_old != "" ]] && hash_new=$(curl -s https://aur.archlinux.org/cgit/aur.git/snapshot/"${aur[$i]}.tar.gz" | md5sum | awk '{print$1}') || hash_new=""
               if [ "$versione_new" != "$versione_old" ] && ([ "$hash_old" != "$hash_new" ] || [ "$hash_old" = "" ]) ; then
                  if [ "$outofdate" != "" ] ; then descrizione="${LIGHT_GREEN}AGGIORNABILE${NC}" ; descr="AGGIORNABILE" ; else descrizione="${LIGHT_GREEN}AGGIORNABILE${NC}(${LIGHT_RED}OutOfDate${NC})" ; descr="AGGIORNABILE_(OutOfDate)" ; fi
                  if [ "$hash_old" = "" ] ; then descrizione=$descrizione"_firme_non_confrontabili" ; fi
                  aur_ok+=($count ${aur[$i]} off)
                  count=$(($count+1))
                  aur[$i]=${aur[$i]}" --->"$descrizione
               else if [ "$outofdate" != "" ] ; then descrizione="${LIGHT_WHITE}AGGIORNATO${NC}" ; else descrizione="${LIGHT_WHITE}AGGIORNATO${NC}(${LIGHT_RED}OutOfDate${NC})" ; fi ; aur[$i]=${aur[$i]}" --->"$descrizione
               fi
            else descrizione="${LIGHT_RED}NON PRESENTE IN AUR${NC}" ; aur[$i]=${aur[$i]}" --->"$descrizione
            fi
         done
         if [ "$aur_ok" = "" ] ; then
            dialog --title "Controllo pacchetti installati" --backtitle "Aggiornamento AUR" --msgbox "Tutti i pacchetti AUR installati sono aggiornati alla versione più recente!" 7 60
         else
            tput cuu 1 ; tput el ; echo "RISULTATO RICERCA PACCHETTI AGGIORNABILI:"
            for ((i=0;i<$numero_AUR;i++)) ; do echo -e ${aur[$i]} ; done
            [[ ${#aur_ok[@]} -eq 3 ]] && echo -e "\tt=aggiorna il pacchetto | altro=esci" || echo -e "\tt=aggiorna tutto | s=seleziona aggiornamenti | altro=esci"
            read -n 1 -s azione
            if [ "$azione" = "s" ] && [ ${#aur_ok[@]} -gt 3 ] ; then
               exec 3>&1 ; select=$(dialog --backtitle "Aggiornamento AUR" --checklist "Seleziona i pacchetti da aggiornare:" 20 70 ${#aur_ok[@]} ${aur_ok[@]} 2>&1 1>&3) ; exitcode=$? ; exec 3>&-
               for i in $select ; do update=$update" "${aur_ok[$(((3*$i)-2))]} ; done
               numero=$(grep -o " " <<<"$update" | wc -l)
               [[ "${update// /}" != "" ]] && updating
            elif [ "$azione" = "t" ] ; then numero=$((${#aur_ok[@]}/3))
               for ((i=0;i<$numero;i++)) ; do ii=$(( ($i*3)+1 )) ; update=$update" "${aur_ok[$ii]} ; done
               updating
            fi
         fi
      else
         dialog --title "Controllo connessione internet" --backtitle "Aggiornamento AUR" --msgbox "Sembra che manchi la connessione, impossibile proseguire." 7 60
      fi
   else dialog --title "Controllo gestione pacchetti (PACMAN)" --backtitle "Aggiornamento AUR" --msgbox "C'è già in esecuzione il gestore pacchetti, attenderne la fine." 7 60
   fi
else echo -e "\nsh aur-update: manca il pacchetto ${LIGHT_WHITE}dialog${NC}, vuoi installarlo (non richiede dipendenze)? [s=si/altro=no]" ; read dialogo
   case $dialogo in
      "s")
         sudo pacman -S dialog ;;
   esac
fi
clear ; echo -e "${LIGHT_GREEN}*****aur-update terminato*****${NC}" && sleep 2
exit 0

digita 'sh aur-update -h' così ti fai una panoramica. quando metti l'opzione '-i' parte l'installer ma prima ti fa vedere info sul pacchetto da installare eppoi ti cihede se installarlo (ancora manca la parte operativa).

ho deciso di non mettere finestre-terminale parenti per editare il pkgbuild e per il makepkg perchè così puoi lanciarlo anche senza DE.
poi si potrebbe mettere uno script eseguibile (es. pacmaur) in /usr/bin con l'istruzione di lancio di aur-update (che DEVE rimanere non eseguibile), in modo da digitare 'pacmaur [-i/-p/-h]'.

lo provo appena posso. oggi ho bestemmie in cirillico xD
far funzionare quella stupida toolchain mi ha distrutto. dopo ore e ore di compilazioni, guide e prove, finalmente sono riuscito ad installare tutto. ora ho due toolchain complete e funzionanti + stm32-coremx... con tanto di .desktop eseguibili.

#chebbello

peccato appia perso due vite XD

tornando IT basta un alias in bash o zsh e risolvi.
io per esempio digito solo # pacup e fa:
mount del subvol
snapshot
unmount
pacman
tuo script
:figo:

rebellion · 26 Gennaio 2018

@e_ale92 cià, ultima versione, adesso c'è tutto:

Codice:

#!/bin/bash
####################################################################################################################
# Gestione AUR v5.0
# Script di aggiornamento pacchetti installati da AUR, by rebellion
#
# Da lanciare tramite terminale per visualizzare messaggi di dialogo con lo script
# a es.: gnome-terminal --geometry 75x25 --hide-menubar --title="Gestore AUR" -e 'sh -c "sh /path/to/aur-update"'
# oppure semplicemente: sh /path/to/aur-update
#
# Per il manuale d'uso digitare: sh aur-update -h
# Gli aggiornamenti sono organizzati in ~/.cache/AUR/$nomepacchetto dove sono presenti PKGBUILD, pkg compilato
#  e lo snapshot scaricato .tar.gz
####################################################################################################################
controllo_dipendenze () {
   check_dip_aur="ok" ; a="\"Depends\"" ; aa="\",\""
   dipendenze=$(curl -s "https://aur.archlinux.org/rpc.php?v=5&type=info&arg=$package_name")
   make_dip=${dipendenze##*MakeDepends} ; if [ "$make_dip" = "$dipendenze" ] ; then make_dip="nessuna" ; else make_dip=${make_dip%%]*} ; make_dip=${make_dip:4} ; make_dip=${make_dip:0: -1} ; make_dip=${make_dip//$aa/ } ; fi
   main_dip=${dipendenze##*$a} ; if [ "$main_dip" = "$dipendenze" ] ; then main_dip="nessuna" ; else main_dip=${main_dip%%]*} ; main_dip=${main_dip:3} ; main_dip=${main_dip:0: -1} ; main_dip=${main_dip//$aa/ } ; fi
   opt_dip=${dipendenze##*OptDepends} ; if [ "$opt_dip" = "$dipendenze" ] ; then opt_dip="nessuna" ; else opt_dip=${opt_dip%%]*} ; opt_dip=${opt_dip:4} ; opt_dip=${opt_dip:0: -1} ; opt_dip=${opt_dip//$aa/ } ; fi
   echo "DIPENDENZE:"
   if [ "$main_dip" != "nessuna" ] ; then
      numero_dipendenze=$(($(grep -o " " <<<"$main_dip" | wc -l)+1))
      for ((ii=1;ii<=$numero_dipendenze;ii++)) ; do dip=$(echo $main_dip | awk -v xx=$ii '{print$xx}') ; dip=${dip%%>*} ; dip=${dip%%<*} ; dip=${dip%%=*} ; if pacman -Q | grep -w "$dip" 1>/dev/null ; then dips="${LIGHT_WHITE}"$dip"${NC}-----> ${LIGHT_GREEN}installata${NC}" ; else dips="${LIGHT_WHITE}"$dip"${NC}-----> ${LIGHT_RED}non installata${NC}" ; fi
         if pacman -Si "$dip" &>/dev/null ; then dips=$dips"(${LIGHT_WHITE}community${NC})" ; else dips=$dips"(${LIGHT_WHITE}AUR${NC})" ; check_dip_aur="no" ; fi
         echo -e $dips
      done
   else echo -e "${LIGHT_WHITE}NESSUNA dipendenza richiesta.${NC}"
   fi
   echo -e "\nDIPENDENZE OPZIONALI:"
   if [ "$opt_dip" != "nessuna" ] ; then
      numero_dipendenze=$(($(grep -o " " <<<"$opt_dip" | wc -l)+1))
      for ((ii=1;ii<=$numero_dipendenze;ii++)) ; do dip=$(echo $opt_dip | awk -v xx=$ii '{print$xx}') ; dip=${dip%%>*} ; dip=${dip%%<*} ; dip=${dip%%=*} ; if pacman -Q | grep -w "$dip" 1>/dev/null ; then dips="${LIGHT_WHITE}"$dip"${NC}-----> ${LIGHT_GREEN}installata${NC}" ; else dips="${LIGHT_WHITE}"$dip"${NC}-----> ${LIGHT_RED}non installata${NC}" ; fi
         if pacman -Si "$dip" &>/dev/null ; then dips=$dips"(${LIGHT_WHITE}community)" ; else dips=$dips"(${LIGHT_WHITE}AUR${NC})" ; fi
         echo -e $dips
      done
   else echo -e "${LIGHT_WHITE}NESSUNA dipendenza opzionale richiesta.${NC}"
   fi
   echo -e "\nDIPENDENZE PER LA COMPILAZIONE (MAKE):"
   if [ "$make_dip" != "nessuna" ] ; then
      numero_dipendenze=$(($(grep -o " " <<<"$make_dip" | wc -l)+1))
      for ((ii=1;ii<=$numero_dipendenze;ii++)) ; do dip=$(echo $make_dip | awk -v xx=$ii '{print$xx}') ; dip=${dip%%>*} ; dip=${dip%%<*} ; dip=${dip%%=*} ; if pacman -Q | grep -w "$dip" 1>/dev/null ; then dips="${LIGHT_WHITE}"$dip"${NC}-----> ${LIGHT_GREEN}installata${NC}" ; else dips="${LIGHT_WHITE}"$dip"${NC}-----> ${LIGHT_RED}non installata${NC}" ; fi
         if pacman -Si "$dip" &>/dev/null ; then dips=$dips"(${LIGHT_WHITE}community${NC})" ; else dips=$dips"(${LIGHT_WHITE}AUR${NC})" ; check_dip_aur="no" ; fi
         echo -e $dips
      done
   else echo -e "${LIGHT_WHITE}NESSUNA dipendenza per la compilazione richiesta.${NC}"
   fi
}
updating () {
      risultato=""
      for ((i=1;i<=$numero;i++)) ; do
         clear
         echo -n "Controllo connessione internet..."
         if ping -q -c 1 -W 1 8.8.8.8 >/dev/null || ping -q -c 1 -W 1 google.com >/dev/null ; then
            echo -e "${LIGHT_WHITE}Connessione ok${NC}"
            package_name=$(echo $update | awk -v x=$i '{print$x}')
            echo -e "Installazione ${LIGHT_WHITE}$package_name${NC}:"
            package_name_tar=$package_name".tar.gz" ; echo -en "ricerca ${LIGHT_WHITE}$package_name_tar${NC}..."
            package_dir_del="/home/$USER/.cache/$package_name"
            package_dir="/home/$USER/.cache/AUR" ; [[ -d "$package_dir" ]] || mkdir /home/$USER/.cache/AUR
            package_path="/home/$USER/.cache/AUR/$package_name_tar" ; package_path_old=$package_path".old"
            package_dir_name="/home/$USER/.cache/AUR/$package_name"
            package_dir_name_old=$package_dir_name"_old"
            echo "fatto." ; echo -n "Ricerca versioni..."
            versione_new=$(curl -s "https://aur.archlinux.org/rpc.php?v=5&type=info&arg=$package_name" | grep "Version") ; outofdate=$(echo $versione_new | grep "OutOfDate\":null") ; [[ "$outofdate" = "" ]] && outofdate="(OutOfDate)" || outofdate=""
            versione_new=${versione_new//,/ } ; versione_new=$(echo $versione_new | awk '{print$8}') ; versione_new=${versione_new:11} ; versione_new=${versione_new:0: -1}$outofdate
            versione_old=$(pacman -Qi $package_name | grep "Versione" | awk '{print$3}')
            echo "fatto." ; echo -e "Versione installata: ${LIGHT_WHITE}$versione_old${NC}\nVersione da installare: ${LIGHT_WHITE}$versione_new${NC}"
            echo -e "\nControllo dipendenze del pacchetto ${LIGHT_WHITE}$package_name${NC}:\n"
            controllo_dipendenze
            pkg="n"
            if [ -f "$package_dir/$package_name/PKGBUILD" ] ; then
               echo ; read -sp "Vuoi consultare il PKGBUILD in locale di $package_name prima di aggiornare? [s/n]" pkg
               if [ "$pkg" = "s" ] ; then clear ; echo -e "${LIGHT_WHITE}$package_dir/$package_name/PKGBUILD${NC}\n" ; cat $package_dir/$package_name/PKGBUILD ; echo ; read -sp "[Premi invio per continuare]" ; fi
            else
               echo ; echo -e "${LIGHT_WHITE}PKGBUILD${NC} in $package_dir/$package_name ${LIGHT_WHITE}assente${NC}." ; read -s -p "[Premi invio per continuare]"
            fi
            if [ "$check_dip_aur" = "ok" ] && dialog --title "pacchetto $package_name" --backtitle "Gestore AUR" --yesno "Verranno installate eventuali dipendenze mancanti presenti in community. Confermi l'aggiornamento?" 7 60 ; then clear
               [[ -d "$package_dir_name" ]] && mv $package_dir_name $package_dir_name_old
               echo -e "Aggiornamento ${LIGHT_WHITE}"$package_name"${NC} in corso, non spengere il pc o la connessione.\nbackup ${LIGHT_WHITE}"$package_dir_del"${NC}---> fatto\nbackup ${LIGHT_WHITE}"$package_name_tar"${NC}---> fatto"
               if wget -P $package_dir https://aur.archlinux.org/cgit/aur.git/snapshot/$package_name_tar ; then
                  tar -xvzf $package_dir/$package_name_tar -C $package_dir
                  read -p "Vuoi consultare il PKGBUILD scaricato? [s/n]" pkg
                  case $pkg in
                     "s")
                        if [ -e "/usr/bin/nano" ] ; then nano /home/$USER/.cache/AUR/$package_name/PKGBUILD ; else echo -e "Editor ${LIGHT_WHITE}nano${NC} non installato.\nVuoi installarlo adesso?" ; read -p "[s=si/n=no]" nan ; [[ "$nan" = "s" ]] && echo "${LIGHT_WHITE}sudo pacman -S nano..." && sudo pacman -S nano && nano /home/$USER/.cache/AUR/$package_name/PKGBUILD ; fi
                     ;;
                  esac
                  echo ; read -p "Confermi l'aggiornamento? [s/n]" pkg
                  if [ "$pkg" = "s" ] ; then
                     cd "$package_dir"/"$package_name"
                     if makepkg -s ; then
                        echo -e "Disinstallazione ${LIGHT_WHITE}$package_name${NC}" ; sudo pacman -R $package_name
                        echo -e "Installazione ${LIGHT_WHITE}$package_name${NC} scaricato" ; sudo pacman -U *.pkg.tar.xz
                        [[ -d "$package_dir_name_old" ]] && echo -en "Rimozione ${LIGHT_WHITE}$package_dir_name_old${NC} di backup..." && rm -r $package_dir_name_old && echo "fatto."
                        package_pkg=$(find /home/$USER/.cache/AUR/$package_name -type f -name "$package_name*" | grep "pkg.tar.xz") ; mv $package_pkg $package_dir
                        package_pkgbuild=$(find /home/$USER/.cache/AUR/$package_name -type f -name "$package_name*" | grep "PKGBUILD") ; mv $package_pkgbuild $package_dir
                        sudo rm -r $package_dir_name ; mkdir $package_dir/$package_name
                        package_pkg=$(find /home/$USER/.cache/AUR -type f -name "$package_name*" | grep "pkg.tar.xz") ; mv $package_pkg $package_dir_name
                        package_pkgbuild=$(find /home/$USER/.cache/AUR -type f -name "$package_name*" | grep "PKGBUILD") ; mv $package_pkg $package_dir_name
                        mv $package_dir/$package_name_tar $package_dir/$package_name
                        dialog --title "pacchetto $package_name" --backtitle "Gestore AUR" --msgbox "Aggiornamento eseguito!" 7 60 ; clear ; risultato=$risultato" "${LIGHT_WHITE}$package_name${NC}"-->${LIGHT_GREEN}installato${NC}\n"
                     else
                        echo "Aggiornamento fallito."
                        echo -en "Rimozione cartella ${LIGHT_WHITE}$package_dir_name${NC} (cartella scompattata ${LIGHT_WHITE}$package_name_tar${NC} scaricato) e ripristino backup..."
                        sudo rm -r $package_dir/$package_name
                        [[ -f "$package_dir"/"$package_name_tar" ]] && rm $package_dir/$package_name_tar
                        [[ -d "$package_dir_name_old" ]] && mv $package_dir_name_old $package_dir_name
                        echo "fatto."
                        read -sp "[Premi invio per continuare]"
                        risultato=$risultato" "${LIGHT_WHITE}$package_name${NC}"-->${LIGHT_RED}non_installato_compilazione_interrotta(make)${NC}\n"
                     fi
                  else
                     risultato=$risultato" "${LIGHT_WHITE}$package_name${NC}"-->${LIGHT_RED}non_installato_per_scelta_utente${NC}\n"
                     echo -en "Rimozione cartella ${LIGHT_WHITE}$package_dir_name${NC} (cartella scompattata ${LIGHT_WHITE}$package_name_tar${NC} scaricato) e ripristino backup..."
                     rm -r $package_dir/$package_name
                     [[ -f "$package_dir"/"$package_name_tar" ]] && rm $package_dir/$package_name_tar
                     [[ -d "$package_dir_name_old" ]] && mv $package_dir_name_old $package_dir_name
                     echo "fatto." ; sleep 2
                  fi
               else
                  [[ -d "$package_dir_name_old" ]] && mv $package_dir_name_old $package_dir_name
                  [[ -f "$package_dir"/"$package_name_tar" ]] && rm $package_dir/$package_name_tar
                  dialog --title "pacchetto $package_name" --backtitle "Gestore AUR" --msgbox "Aggiornamento fallito, sembra che AUR non contenga il pacchetto da aggiornare. Ripristinato il backup del pacchetto." 7 60 ; clear
                  risultato=$risultato" "${LIGHT_WHITE}$package_name${NC}"-->${LIGHT_RED}non_installato_non_presente_in_AUR${NC}\n"
               fi
            else
               [[ "$check_dip_aur" = "ok" ]] && risultato=$risultato" "${LIGHT_WHITE}$package_name${NC}"-->${LIGHT_RED}non_installato_per_scelta_utente${NC}\n" || risultato=$risultato" "${LIGHT_WHITE}$package_name${NC}"-->${LIGHT_RED}non installato per mancanza dipendenze AUR${NC}\n"
            fi
         else
            dialog --title "Controllo connessione internet" --backtitle "Gestore AUR" --msgbox "Connessione assente, aggiornamento fallito. $package_name ripristinato all'ultima versione." 7 60 ; clear
            risultato=$risultato" "${LIGHT_WHITE}$package_name${NC}"-->${LIGHT_RED}non_installato_per_assenza_connessione_internet${NC}\n"
         fi
      done
      clear ; echo "Riassunto aggiornamento:" ; echo -e "\n$risultato" ; echo ; echo "[premi invio per terminare]" ; read -s -n 1
}
installer () {
  echo -en "\n Controllo connessione internet..."
  if ping -q -c 1 -W 1 8.8.8.8 >/dev/null || ping -q -c 1 -W 1 google.com >/dev/null ; then
   echo -e "${LIGHT_WHITE}connesso a internet.${NC}\n"
   PACK_locale=$(pacman -Q $PACK 2>/dev/null)
   PACK_aur=$(curl -s "https://aur.archlinux.org/rpc.php?v=5&type=info&arg=$PACK")
   PACK_aur_check=${PACK_aur##*resultcount} ; PACK_aur_check=${PACK_aur_check:2:1}
   if [ "$PACK_locale" != "" ] ; then pacman -Qi $PACK ; read -sp "[premi invio per continuare]"
   else
      case $PACK_aur_check in
         "0")
            echo -e "${LIGHT_WHITE}$PACK${LIGHT_RED} non presente in AUR.${NC}" ; read -sp "[premi invio per continuare]" ;;
         * )
            aaaa="\"" ; stampa=$(echo $PACK_aur | grep Name) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*Name} && stampa=${stampa%%,*} && stampa=${stampa:3} && stampa=${stampa:0: -1} ; echo -e "\nNome                    : ${LIGHT_WHITE}$stampa${NC}"
             stampa=$(echo $PACK_aur | grep Version) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*Version} && stampa=${stampa%%,*} && stampa=${stampa:3} && stampa=${stampa:0: -1} ; echo -e "Versione                : ${LIGHT_WHITE}$stampa${NC}"
            stampa=$(echo $PACK_aur | grep Description) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*Description} ; stampa=${stampa%%,*} ; stampa=${stampa:3} ; stampa=${stampa:0: -2} ; echo -e "Descrizione             : ${LIGHT_WHITE}$stampa${NC}"
            aaa="\"URL\"" ; stampa=$(echo $PACK_aur | grep "$aaa") ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*$aaa} ; stampa=${stampa%%,*} ; stampa=${stampa:2} ; stampa=${stampa:0: -1} && stampa=${stampa//\\/} ; echo -e "URL                     : ${LIGHT_WHITE}${stampa// /}${NC}"
            aaa="\"Depends\"" ; stampa=$(echo $PACK_aur | grep "$aaa") ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*$aaa} && stampa=${stampa%%]*} && stampa=${stampa:2} && stampa=${stampa//,/ } ; echo -e "Dipendenze              : ${LIGHT_WHITE}${stampa//$aaaa/}${NC}"
            stampa=$(echo $PACK_aur | grep OptDepends) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*OptDepends} && stampa=${stampa%%]*} && stampa=${stampa:3} && stampa=${stampa//,/ } ; echo -e "Dipendenze Opzionali    : ${LIGHT_WHITE}${stampa//$aaaa/}${NC}"
            stampa=$(echo $PACK_aur | grep MakeDepends) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*MakeDepends} && stampa=${stampa%%]*} && stampa=${stampa:3} && stampa=${stampa//,/ } ; echo -e "Dipendenze Compilazione : ${LIGHT_WHITE}${stampa//$aaaa/}${NC}"
            stampa=$(echo $PACK_aur | grep OutOfDate) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*OutOfDate} && stampa=${stampa%%,*} && stampa=${stampa:2} ; echo -e "Flag                    : ${LIGHT_WHITE}$stampa${NC}"
            stampa=$(echo $PACK_aur | grep Maintainer) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*Maintainer} && stampa=${stampa%%,*} && stampa=${stampa:3} && stampa=${stampa:0: -1} ; echo -e "Mainteiner              : ${LIGHT_WHITE}$stampa${NC}"
            stampa=$(echo $PACK_aur | grep Conflicts) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*Conflicts} && stampa=${stampa%%]*} && stampa=${stampa:3} && stampa=${stampa//,/ } ; echo -e "Confligge               : ${LIGHT_WHITE}${stampa//$aaaa/}${NC}"
            stampa=$(echo $PACK_aur | grep Provides) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*Provides} && stampa=${stampa%%]*} && stampa=${stampa:3} && stampa=${stampa//,/ } ; echo -e "Fornisce                : ${LIGHT_WHITE}${stampa//$aaaa/}${NC}"
            stampa=$(echo $PACK_aur | grep Replaces) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*Replaces} && stampa=${stampa%%]*} && stampa=${stampa:3} && stampa=${stampa//,/ } ; echo -e "Rimpiazza               : ${LIGHT_WHITE}${stampa//$aaaa/}${NC}"
            stampa=$(echo $PACK_aur | grep License) ; [[ "$stampa" != "" ]] && stampa=${PACK_aur##*License} && stampa=${stampa%%,*} && stampa=${stampa:3} && stampa=${stampa:0: -1} ; echo -e "Licenze                 : ${LIGHT_WHITE}${stampa//$aaaa}${NC}\n"
            package_name=$PACK ; controllo_dipendenze
            if [ "$check_dip_aur" = "ok" ] ; then              
               read -n 1 -p "Vuoi installarlo (assieme a eventuali dipedenze non opzionali mancanti)? [s=si/n=no]" ins
               if [ "$ins" = "s" ] ; then
                check=$(ps aux | grep "[s]udo pacman")
                if [ "$check" = "" ] ; then
                  echo -e "\nInstallazione ${LIGHT_WHITE}$PACK${NC}:"
                  [[ ! -d "/home/$USER/.cache/AUR" ]] && echo -en "Creazione cartella ${LIGHT_WHITE}/home/$USER/.cache/AUR${NC}..." && mkdir /home/$USER/.cache/AUR && echo "fatto."
                  echo -en "Creazione cartella ${LIGHT_WHITE}/home/$USER/.cache/AUR/$PACK${NC}..." && mkdir /home/$USER/.cache/AUR/$PACK && echo "fatto."
                  wget -P /home/$USER/.cache/AUR https://aur.archlinux.org/cgit/aur.git/snapshot/$PACK".tar.gz"
                  tar -xvzf /home/$USER/.cache/AUR/$PACK".tar.gz" -C /home/$USER/.cache/AUR
                  echo ; read -p "Vuoi consultare il PKGBUILD scaricato? [s/n]" pkg
                  case $pkg in
                     "s")
                        if [ -e "/usr/bin/nano" ] ; then nano /home/$USER/.cache/AUR/$PACK/PKGBUILD ; else echo -e "Editor ${LIGHT_WHITE}nano${NC} non installato.\nVuoi installarlo adesso?" ; read -p "[s=si/n=no]" nan ; [[ "$nan" = "s" ]] && echo "${LIGHT_WHITE}sudo pacman -S nano..." && sudo pacman -S nano && nano /home/$USER/.cache/AUR/$PACK/PKGBUILD ; fi
                     ;;
                  esac
                  echo ; read -p "Confermi l'aggiornamento? [s/n]" pkg
                  if [ "$pkg" = "s" ] ; then
                     cd /home/$USER/.cache/AUR/$PACK
                     if makepkg -s ; then
                        package=$(find /home/$USER/.cache/AUR/$PACK -maxdepth 1 -type f -name "*.pkg.tar.xz" | grep "$PACK")
                        sudo pacman -U /home/$USER/.cache/AUR/$PACK/$package
                        echo -en "Pulizia cartella ${LIGHT_WHITE}/home/$USER/.cache/AUR/$PACK${NC}..."
                        mv /home/$USER/.cache/AUR/$PACK/$package /home/$USER/.cache/AUR/$package
                        mv /home/$USER/.cache/AUR/$PACK/PKGBUILD /home/$USER/.cache/AUR/PKGBUILD
                        sudo rm -r /home/$USER/.cache/AUR/$PACK && mkdir /home/$USER/.cache/AUR/$PACK
                        mv /home/$USER/.cache/AUR/$package /home/$USER/.cache/AUR/$PACK/$package
                        mv /home/$USER/.cache/AUR/PKGBUILD /home/$USER/.cache/AUR/$PACK/PKGBUILD
                        echo "fatto." ; echo "Installazione terminata." ; read -p "[Premi invio per terminare]"
                     else echo "Installazione fallita."
                        echo -ne "Rimozione cartella ${LIGHT_WHITE}/home/$USER/.cache/AUR/$PACK${NC} e $PACK.tar.gz scaricato.." && sudo rm -r /home/$USER/.cache/AUR/$PACK && rm /home/$USER/.cache/AUR/$PACK".tar.gz" && echo "fatto."
                     fi
                  else echo -ne "Rimozione cartella ${LIGHT_WHITE}/home/$USER/.cache/AUR/$PACK${NC} e $PACK.tar.gz scaricato.." && sudo rm -r /home/$USER/.cache/AUR/$PACK && rm /home/$USER/.cache/AUR/$PACK".tar.gz" && echo "fatto."
                  fi
                else dialog --title "Controllo gestione pacchetti (PACMAN)" --backtitle "Gestore AUR" --msgbox "C'è già in esecuzione il gestore pacchetti, attenderne la fine." 7 60
                fi
               fi
            else echo -e "\nMancano alcune dipendenze installabili da AUR.\n" ; read -sp "[Premi invio per terminare..]"
            fi
         ;;
      esac
   fi
  else dialog --title "Controllo connessione internet" --backtitle "Gestore AUR" --msgbox "Sembra che manchi la connessione, impossibile proseguire." 7 60
  fi
}
controllo_pacchetto () {
   quit=0 ; for i in $(pacman -Qqm) ; do if [ "$i" = "$AUR" ] ; then quit=1 ; fi ; done
   [[ $quit -eq 0 ]] && echo -e "$0: pacchetto '${LIGHT_WHITE}$AUR${NC}' non installato." && exit 0
}
LIGHT_RED='\033[0;31m' ; LIGHT_GREEN='\033[0;32m' ; LIGHT_WHITE='\033[1;37m' ; NC='\033[0m'
if pacman -Q dialog &>/dev/null ; then
   if [ "$#" -lt 3 ] ; then
      if [ "$1" = "-p" ] && [ "$2" = "" ] ; then clear ; read -p "Inserisci il pacchetto da aggiornare> " AUR ; numero_AUR=1 ; controllo_pacchetto
      elif [ "$1" != "-p" ] && [ "$1" != "-i" ] && [ "$1" != "-h" ] && [ "$1" != "" ] ; then echo -e "sh $0: opzione '${LIGHT_WHITE}$1${NC}' non valida.\nsh $0: prova '${LIGHT_WHITE}-h${NC}' per help e info." ; exit 0
      elif [ "$1" = "-p" ] && [ "$2" != "" ] ; then AUR=$2 ; numero_AUR=1 ; controllo_pacchetto
      elif [ "$1" = "" ] ; then
         AUR=$(pacman -Qqm)
         numero_AUR=$(pacman -Qqm | wc -l)
      elif [ "$1" = "-i" ] ; then [[ "$2" = "" ]] && read -p "Inserisci il pacchetto AUR da installare> " PACK || PACK=$2 ; installer ; echo -e "\n${LIGHT_GREEN}*****$0 terminato*****${NC}" && sleep 2 ; exit 0
      elif [ "$1" = "-h" ] ; then clear ; echo -e "MANUALE $0:\n\n${LIGHT_WHITE}NOME E DESCRIZIONE${NC}\n   $0 - utility aggiornamento/installazione pacchetti AUR\n\n${LIGHT_WHITE}SINOSSI${NC}\n   ${LIGHT_WHITE}Uso${NC}\n      sh $0 [OPZIONI] [nomepacchetto]\n\n${LIGHT_WHITE}OPZIONI\n   -p,${NC}      aggiornamento con richiesta del nomepacchetto\n\n${LIGHT_WHITE}   -p NOMEPACCHETTO,\n${NC}      aggiornamento NOMEPACCHETTO\n\n${LIGHT_WHITE}   -i,${NC}\n      installazione con richiesta del nomepacchetto\n\n${LIGHT_WHITE}   -i NOMEPACCHETTO,\n${NC}      installazione NOMEPACCHETTO\n\n\n${LIGHT_GREEN}*****SOFTWARE BY REBELLION, FREE AND WITHOUT LICENSE*****${NC}" ; exit 0
      else exit 0
      fi
   else echo -e "sh $0: troppi argomenti -- ${LIGHT_WHITE}$@${NC}.\nsh $0: prova '${LIGHT_WHITE}-h${NC}' per help e info." ; exit 0
   fi
   if [ "$(pacman -Qqm | grep -w "$AUR")" = "" ] ; then echo -e "sh $0: pacchetto ${LIGHT_WHITE}$AUR${NC} non trovato." ; exit 0 ; fi
   check=$(ps aux | grep "[s]udo pacman")
   if [ "$check" = "" ] ; then
      clear && echo -n "Controllo connessione internet..."
      if ping -q -c 1 -W 1 8.8.8.8 >/dev/null || ping -q -c 1 -W 1 google.com >/dev/null ; then
         echo -e "${LIGHT_WHITE}Connesso a internet.${NC}"
         echo -e "\nCONTROLLO PACCHETTI AGGIORNABILI, attendere..."
         aur=()
         aur_ok=()
         update=""
         count=1
         for ((i=0;i<$numero_AUR;i++)) ; do ii=$((i+1)) ; aur[$i]=$(echo $AUR | awk -v x=$ii '{print$x}')
            tput cuu 1 ; tput cuf 47 ; echo "[$(($i+1))/$numero_AUR]" ; tput el ; echo -e ${LIGHT_WHITE}${aur[$i]}${NC} ; tput cuu 1
            versione_new=$(curl -s "https://aur.archlinux.org/rpc.php?v=5&type=info&arg=${aur[$i]}" | grep "Version") ; outofdate=$(echo $versione_new | grep "OutOfDate\":null")
            if [ "$versione_new" != "" ] ; then
               versione_new=${versione_new//,/ } ; versione_new=$(echo $versione_new | awk '{print$8}') ; versione_new=${versione_new:11} ; versione_new=${versione_new:0: -1}
               versione_old=$(pacman -Qi ${aur[$i]} | grep "Versione" | awk '{print$3}')
               package_path=$(find /home/$USER -type f -name "${aur[$i]}.tar.gz") ; package_path=$(echo $package_path | awk '{print$1}')
               [[ $package_path != "" ]] && hash_old=$(md5sum $package_path | awk '{print$1}') || hash_old=""
               [[ $hash_old != "" ]] && hash_new=$(curl -s https://aur.archlinux.org/cgit/aur.git/snapshot/"${aur[$i]}.tar.gz" | md5sum | awk '{print$1}') || hash_new=""
               if [ "$versione_new" != "$versione_old" ] && ([ "$hash_old" != "$hash_new" ] || [ "$hash_old" = "" ]) ; then
                  if [ "$outofdate" != "" ] ; then descrizione="${LIGHT_GREEN}AGGIORNABILE${NC}" ; descr="AGGIORNABILE" ; else descrizione="${LIGHT_GREEN}AGGIORNABILE${NC}(${LIGHT_RED}OutOfDate${NC})" ; descr="AGGIORNABILE_(OutOfDate)" ; fi
                  if [ "$hash_old" = "" ] ; then descrizione=$descrizione"_firme_non_confrontabili" ; fi
                  aur_ok+=($count ${aur[$i]} off)
                  count=$(($count+1))
                  aur[$i]=${aur[$i]}" --->"$descrizione
               else if [ "$outofdate" != "" ] ; then descrizione="${LIGHT_WHITE}AGGIORNATO${NC}" ; else descrizione="${LIGHT_WHITE}AGGIORNATO${NC}(${LIGHT_RED}OutOfDate${NC})" ; fi ; aur[$i]=${aur[$i]}" --->"$descrizione
               fi
            else descrizione="${LIGHT_RED}NON PRESENTE IN AUR${NC}" ; aur[$i]=${aur[$i]}" --->"$descrizione
            fi
         done
         if [ "$aur_ok" = "" ] ; then
            dialog --title "Controllo pacchetti installati" --backtitle "Gestore AUR" --msgbox "Tutti i pacchetti AUR installati sono aggiornati alla versione più recente!" 7 60
         else
            tput cuu 1 ; tput el ; echo "RISULTATO RICERCA PACCHETTI AGGIORNABILI:"
            for ((i=0;i<$numero_AUR;i++)) ; do echo -e ${aur[$i]} ; done
            [[ ${#aur_ok[@]} -eq 3 ]] && echo -e "\tt=aggiorna il pacchetto | altro=esci" || echo -e "\tt=aggiorna tutto | s=seleziona aggiornamenti | altro=esci"
            read -n 1 -s azione
            if [ "$azione" = "s" ] && [ ${#aur_ok[@]} -gt 3 ] ; then
               exec 3>&1 ; select=$(dialog --backtitle "Gestore AUR" --checklist "Seleziona i pacchetti da aggiornare:" 20 70 ${#aur_ok[@]} ${aur_ok[@]} 2>&1 1>&3) ; exitcode=$? ; exec 3>&-
               for i in $select ; do update=$update" "${aur_ok[$(((3*$i)-2))]} ; done
               numero=$(grep -o " " <<<"$update" | wc -l)
               [[ "${update// /}" != "" ]] && updating
            elif [ "$azione" = "t" ] ; then numero=$((${#aur_ok[@]}/3))
               for ((i=0;i<$numero;i++)) ; do ii=$(( ($i*3)+1 )) ; update=$update" "${aur_ok[$ii]} ; done
               updating
            fi
         fi
      else
         dialog --title "Controllo connessione internet" --backtitle "Gestore AUR" --msgbox "Sembra che manchi la connessione, impossibile proseguire." 7 60
      fi
   else dialog --title "Controllo gestione pacchetti (PACMAN)" --backtitle "Gestore AUR" --msgbox "C'è già in esecuzione il gestore pacchetti, attenderne la fine." 7 60
   fi
else echo -e "\nsh $0: manca il pacchetto ${LIGHT_WHITE}dialog${NC}, vuoi installarlo (non richiede dipendenze)? [s=si/altro=no]" ; read dialogo
   case $dialogo in
      "s")
         sudo pacman -S dialog ;;
   esac
fi
clear ; echo -e "${LIGHT_GREEN}*****$0 terminato*****${NC}" && sleep 2
exit 0

con gli alias sono un po'cane lupo, volessi usare 'pacmaur' con opzioni cosa potrei scrivere in .bashrc? ho pensato a questo:

Codice:

pacmaur='opzioni="aur-update" ; for i in $@ ; do opzioni=$opzioni" $i" ; done ; sh /path/to/$opzioni'

ma non funziona.

e_ale92 · 26 Gennaio 2018

aaahhh grande! io stamattina ho provato la -4 ma non avevo update da fare. ho testato dialog e il manuale. tanta roba.

non funziona perché sbagli procedura.
gli alias vanno settati in .bashrc (o .zshrc, nel mio caso) e hanno una struttura simile a quella che puoi leggere nell'esempio [4] indicato qui: https://wiki.archlinux.org/index.php/Bash#Aliases

per evitare di avere un .bashrc lungo due chilometri, puoi fare come ho fatto io. crei un file contenente tutti gli alias, lo piazzi dove vuoi e istruisci bashrc perché carichi tutti gli alias presenti in elenco.

source $HOME/.zsh/alias.zsh

e in quel file ho elencato tutti gli alias :)
es.

Codice:

alias la='ls -a' 
alias pacup='sudo mount -t btrfs -o subvol=/ /dev/sda2 /mnt/btrfs && sudo btrfs subvolume snapshot / /mnt/btrfs/snap-root/root-pacup--$(date +%b.%d.%y--%H:%M) && sudo umount /mnt/btrfs && sudo pacman -Syu && /usr/bin/bash /home/bcclsn/.script/aur_update.sh'

p. s. ti consiglio di leggere da pc o su schermo grande. eventualmente sappi che il comando di alias pacup è tutto su una riga.

e_ale92 · 27 Gennaio 2018

@rebellion: tanta roba l'opzione "-i" :sac:

UFFICIALE L'OT di Linux e altri OS

Utente Attivo