That’s why I made some small utilities. And uploaded them to my Github. Until the time, there are only two small scripts (one made with python, the another with bash) who simplifies the mental transition between distros.

The first one, service, is just a simple translation to systemctl (I know, it’s not only related to Arch but any systemd distro. But I haven’t changed yet completely my way for calling start|stop|restart services). Apt.py, as its name suggests, is an apt-to-pacman translation with many, MANY lacks of functionality, but still usable on daily work.

I will explain with an example: I haven’t uploaded the system for a while right now, so I want to perform ‘apt-get update’ to receive the new packages list and ‘apt-get upgrade’ to upgrade them. Well, with apt.py (installed by setup.sh), I can handle it easily:

~$ sudo apt-get update

pacman -Sy
core is updated
extra is updated
community is updated
multilib is updated

Or force the package update, even if it says the zips are updated:

sudo apt-get update –force

pacman -Syy
:: Sincronizando las bases de datos de los paquetes...
 core                          134,6 KiB   302K/s 00:00 [############################] 100%
 extra                        1937,6 KiB   451K/s 00:04 [############################] 100%
 community                       3,1 MiB   263K/s 00:12 [############################] 100%
 multilib                      171,7 KiB   695K/s 00:00 [############################] 100%

Note the pacman -Sy the program prints. It’s because my translator doesn’t want to be a substitute of pacman, but a simpler way to understand it through the apt approaching.

Hope it helps. Suggestions, as always, are welcome :D

No hay problema: un pequeño script en python lee de un archivo de texto y le manda, línea a línea, su contenido al ejecutable que hayamos elegido.

Seguramente haya muchas cosas por pulir, pero hace lo que tiene que hacer (Pricipio KISS, que le llaman ;) ).

Uso: sendlines -f Fichero_de_texto -c "comando a ejecutar" [ -d delay ], donde:

• fichero_de_texto: archivo que contiene las lineas que se van a mandar. No contempla comentarios, lo manda del tirón
• comando: orden que recibirá las entradas de fichero_de_texto. Si tiene parámetros, poner todo el comando entre comillas (ej: "grep -v grep")
• delay: tiempo entre lineas. Opcional, espera un tiempo (en segundos) entre cada linea que manda

</p>

<h1>!/usr/bin/env python</h1>

<h1>-<em>- coding: utf-8 -</em>-</h1>

<p>import subprocess
import time
import sys, getopt</p>

<p>def run(cmd,textFile,delay):
    with open(textFile,&lsquo;r&rsquo;) as text:
        content=text.readlines()
    p = subprocess.Popen(cmd,stdout=subprocess.PIPE,stdin=subprocess.PIPE)
    for line in content:
        p.stdin.write(line+&lsquo;\n&rsquo;)
        if(delay): time.sleep(float(delay))
    p.communicate()[0]
    p.stdin.close()</p>

<p>def usage():
    print &lsquo;&rsquo;&lsquo;
        Usage: sendlines -f textFile -c &ldquo;COMMAND&rdquo; [ -d DELAY ]
        - textFile: Text file where read lines from. Mandatory.
        - COMMAND: Command to be executed (if there are any arguments to be sent, must be put all between quotes). Mandatory
        - DELAY: Time (in seconds) to wait between sending lines. Optional.
        &rsquo;&lsquo;&rsquo;
if <strong>name</strong> == &ldquo;<strong>main</strong>&rdquo;:
    textFile = None
    command = None
    delay = None
    try:
        opts, args = getopt.getopt(sys.argv[1:], &ldquo;f:c:d:&rdquo;, [&ldquo;file=&rdquo;, &ldquo;command=&rdquo;, &ldquo;delay=&rdquo;])
    except getopt.GetoptError as err:
        # print help information and exit:
        print str(err) # will print something like &ldquo;option -a not recognized&rdquo;
        sys.exit(2)
    for o, a in opts:
        if o in (&ldquo;-f&rdquo;, &ldquo;&ndash;file&rdquo;):
            textFile = a
        elif o in (&ldquo;-c&rdquo;, &ldquo;&ndash;command&rdquo;):
            command = a.split(&lsquo; &rsquo;)
        elif o in (&ldquo;-d&rdquo;, &ldquo;&ndash;delay&rdquo;):
            delay = a
        else:
            assert False, &ldquo;unhandled option&rdquo;
            usage()
    if(command and textFile):
        run(command,textFile,delay)
    else:
        usage()
        print &lsquo;Missing argument(s). Exit\n&rsquo;
        sys.exit(2)

En una forma rápida, podemos lanzar este proceso:

pg_dump -h $MAQUINA -U $USER -d $DATABASE -Fd -j `nproc` -f $DESTINO

Las variables son autorreferentes, con lo que la gracia de este comando se encuentra en la opción -Fd (obligatoria para que use diferentes cores), que realiza el dump en un directorio en lugar de un archivo; y la opción -j, que refiere al número de procesos que se lanzan simultáneamente. En este caso, hacemos uso de lo que devuelve nproc para levantar tantos procesos como núcleos.

Un pequeño script de backup de base de datos local (perfecto para meter en un cronjob del usuario postgres) sería:

</p>

<h1>!/bin/bash</h1>

<h2>This script will create a backup for each database listed in the DATABASES variable</h2>

<h2>Use as postgres user or add the -U [username] to the pg_dump line</h2>

<p>DATABASES=&ldquo;template1 db other_db&rdquo;
CORES=<code>nproc</code>
TARGET_FOLDER=/var/backups</p>

<p>for DATABASE in $DATABASES; do
    mkdir -p $TARGET_FOLDER/$DATABASE
    pg_dump -d $DATABASE -Fd -j $CORES -f $TARGET_FOLDER/$DATABASE
done