¿Cómo hacer que un administrador de paquetes espere si se está ejecutando otra instancia de APT?

He visto muchos softwares como Update Manager y Synaptic Package Manager, esperan si algún otro programa está usando /var/lib/dpkg/locky está bloqueado. ¿Cómo podemos hacer esto a través de la Terminal? Vi apt-getel manual pero no encontré nada útil.

Puede usar el aptdconcomando para poner en cola las tareas del administrador de paquetes comunicándose con aptdaemon en lugar de usar apt-get directamente.

Básicamente, puede hacer sudo aptdcon --install chromium-browserlo que sea y mientras se ejecuta ese comando, puede ejecutarlo nuevamente, pero instale diferentes paquetes y apt-daemon simplemente los pondrá en cola en lugar de generar errores.

Esto es especialmente útil si está realizando una actualización larga o algo así y desea seguir instalando paquetes o si está creando una secuencia de comandos juntos y quiere asegurarse de que la instalación sea más confiable.

Puede apt-getaprender a esperar si se está ejecutando otro administrador de software. Algo similar con el comportamiento del próximo elenco de pantalla:

¿Cómo lo hice?

Creo un nuevo script llamado apt-get(wrapper for apt-get) en el /usr/local/sbindirectorio con el siguiente código bash dentro:

#!/bin/bash

i=0
tput sc
while fuser /var/lib/dpkg/lock >/dev/null 2>&1 ; do
    case $(($i % 4)) in
        0 ) j="-" ;;
        1 ) j="\\" ;;
        2 ) j="|" ;;
        3 ) j="/" ;;
    esac
    tput rc
    echo -en "\r[$j] Waiting for other software managers to finish..." 
    sleep 0.5
    ((i=i+1))
done 

/usr/bin/apt-get "$@"

No olvides hacerlo ejecutable:

sudo chmod +x /usr/local/sbin/apt-get

Antes de realizar la prueba, verifique si todo está bien. La salida del which apt-getcomando debería ser ahora /usr/local/sbin/apt-get. El motivo es: de manera predeterminada, el /usr/local/sbindirectorio se coloca antes del /usr/bindirectorio en usuario o raíz PATH.

Aparte de lo obvio &&, puede estar buscando aptdcon. Esta herramienta puede detectar otras instancias de apt y esperar a que finalicen:

sudo aptdcon --safe-upgrade
[/] 11% Esperando a que otros administradores de software salgan Esperando aptitud

(Estoy corriendo aptitud en otro lugar)

La ventaja de esta herramienta es que puede almacenar varias acciones consecutivas sin preocuparse de lo que hará a continuación. aptdcones ideal para scripts desatendidos e instalación de GUI, ya que puede permitir que la herramienta se ejecute en segundo plano para no bloquear su interfaz.

Las operaciones soportadas por aptdconson:

• --refresh, -c: Esto es equivalente a apt-get update. Actualiza tu lista de paquetes.
• --install` --remove` --upgrade` --purge` --downgrade. Cada uno de ellos hace lo que dicen sus nombres. El nombre del paquete (s) es obligatorio. -i, -r, -u, -p: Estas son las opciones cortos para todos excepto rebaja, que no tiene uno.
• --safe-upgrade, --full-upgradeson las contrapartes de apt-get's upgrade/ dist-upgradey aptitude' s safe-upgrade/ full-upgrade. Estos no necesitan parámetros.
• Hay varias otras operaciones, que se pueden encontrar en el manual. Pero, estos son los más utilizados por los usuarios interesados aptd. Hay opciones que se superponen con lo que apt-key, apt-cache, dpkghacer.

apt-geten sí mismo no es compatible con dichos métodos (para esperar otras instancias de apt), por lo que aptdcones la solución preferida para los administradores de paquetes de GUI: USC usa aptdcomo back-end, igual que Synaptic. Otra solución es packagekit, pero no es compatible con la función que está buscando (todavía).

Un enfoque muy simple sería un script que esperara a que el bloqueo no se abra. Vamos a llamarlo waitforapty pegarlo /usr/local/bin:

#!/bin/sh

while sudo fuser /var/{lib/{dpkg,apt/lists},cache/apt/archives}/lock >/dev/null 2>&1; do
   sleep 1
done

Entonces solo corre sudo waitforapt && sudo apt-get install whatever. Puede agregar excepciones sudoerspara permitirle ejecutarlo sin necesidad de una contraseña (la necesitará para apt-getque no sea una gran ganancia).

Lamentablemente, esto no pone en cola las cosas. Dado que algunas de las operaciones de apt son interactivas ("¡¿Estás seguro de que quieres eliminar todos esos paquetes ?!"), no puedo ver una buena forma de evitar esto ...

Podría usar una técnica de sondeo:

$ time (while ps -opid= -C apt-get > /dev/null; do sleep 1; done); \
  apt-get -y install some-other-package

Hice un script que hace esto:

#!/bin/bash

# File path to watch
LOCK_FILE='/var/lib/dpkg/lock'

# tput escape codes
cr="$(tput cr)"
clr_end="$(tput el)"
up_line="$(tput cuu 1)"

CLEAN(){
    # Cleans the last two lines of terminal output,
    # returns the cursor to the start of the first line
    # and exits with the specified value if not False

    echo -n "$cr$clr_end"
    echo
    echo -n "$cr$clr_end$up_line"
    if [[ ! "$1" == "False" ]]; then
        exit $1
    fi
}

_get_cmdline(){
    # Takes the LOCKED variable, expected to be output from `lsof`,
    # then gets the PID and command line from `/proc/$pid/cmdline`.
    #
    # It sets `$open_program` to a user friendly string of the above.

    pid="${LOCKED#p}"
    pid=`echo $pid | sed 's/[\n\r ].*//'`
    cmdline=()
    while IFS= read -d '' -r arg; do
        cmdline+=("$arg")
    done < "/proc/${pid}/cmdline"
    open_program="$pid : ${cmdline[@]}"
}

# Default starting value
i=0

# Checks if the file is locked, writing output to $FUSER
while LOCKED="$(lsof -F p "$LOCK_FILE" 2>/dev/null)" ; do
    # This will be true if it isn't the first run
    if [[ "$i" != 0 ]]; then
        case $(($i % 4)) in
            0 ) s='-'
                i=4
                _get_cmdline # Re-checks the command line each 4th iteration
            ;;
            1 ) s=\\ ;;
            2 ) s='|' ;;
            3 ) s='/' ;;
        esac
    else
        # Traps to clean up the printed text and cursor position
        trap "CLEAN False; trap - SIGINT ; kill -SIGINT $$" SIGINT
        trap 'CLEAN $((128+15))' SIGTERM
        trap 'CLEAN $((128+1))' SIGHUP
        trap 'CLEAN $((128+3))' SIGQUIT

        # Default starting character
        s='-'

        _get_cmdline
        echo -n "$save_cur"
    fi
    # Prints the 2nd line first so the cursor is at the end of the 1st line (looks nicer)
    echo
    echo -n "$cr$clr_end$open_program"
    echo -n "$up_line$res_cur$cr$clr_end[$s] Waiting for other package managers to finish..."
    #echo -en "$cr$clr_end[$s] Waiting for other package managers to finish..."
    #echo -en "\n$cr$clr_end$open_program$cr$up_line"
    ((i++))
    sleep 0.025
done

CLEAN False

# This allows saving the script under a different name (e.g. `apt-wait`)
# and running it. It only imitates `apt-get` if it was launched as such
if [[ "${0##*/}" == 'apt-get' ]]; then
    exec /usr/bin/apt-get "$@"
    exit $?
fi

Guarde lo anterior en /usr/local/sbin/apt-get. apt-getluego esperará si ya se está ejecutando otra instancia.

Alternativamente, guárdelo como /usr/local/sbin/apt-wait, ejemplo de uso:

apt-wait && aptitude

que se ejecutará aptitudedespués de que el proceso actual que mantiene el bloqueo haya salido

Ejemplo de ejecución:

1. Primero, apt-getse ejecuta un comando, por ejemplo:

   $ sudo apt-get remove some_package
   

2. Luego, en otra terminal, se ejecuta otro comando:

   $ sudo apt-get install some_other_package
   

   Esperará a que termine el primer comando y luego se ejecutará. Salida mientras espera:

   [/] Waiting for other package managers to finish...
         28223 : /usr/bin/apt-get remove some_package
   

Desafortunadamente, el fusor no hace mucho por usted cuando está ejecutando en diferentes contenedores de espacios de nombres sin privilegios como lxc.

Además, aptdcon no está instalado de manera predeterminada (al menos en 18.04) y pone en segundo plano su tarea en una cola para que pierda la serialización. Esto no es insuperable, pero significa que su automatización necesita tener alguna forma de evitar errores de flock en apt al instalar aptdcon, y necesitará tener algún tipo de bucles de espera para cualquier cosa que necesite serializar después de instalar paquetes a través de aptdcon a menos que ya haya algún tipo de bandera para eso.

Lo que funciona es rebaño. Esto también debería funcionar sobre NFS, etc., ya que utiliza el bloqueo del sistema de archivos de la misma manera que lo hace apt, solo con el parámetro -w segundos esperará en su bloqueo en lugar de arrojar un error.

Entonces, siguiendo el modelo de contenedor, agregue esto como apt-get in / usr / local / bin / y comparta.

Esto también tiene el beneficio de limitar IO al no permitir el paralelismo en apt para que pueda permitir que cron se active a medianoche en todas partes sin golpear el disco.

#!/bin/bash
exec /usr/bin/flock -w 900 -F --verbose /var/cache/apt/archives/lock /usr/bin/apt-get $@  

Una solicitud de función muy agradable y simple para apt-get sería una bandera -w para cambiar a un bloqueo / bloqueo de espera.

One-liner basado en la respuesta de Oli :

while sudo fuser /var/{lib/{dpkg,apt/lists},cache/apt/archives}/lock >/dev/null 2>&1; do sleep 1; done