Recently I’ve changed my laptop main distro from Debian to Manjaro (an Arch-based distribution). Does it mean that the Carmina Burana’s “Oh Fortuna” plays while apt-get falls into the depths of Oblivion? Well, technically yes. I mean, I can listen “Oh Fortuna” or any other piece of music while any linux distribution is being installed. And trully, pacman is NOT apt tools (It doesn’t mean better or worse, just means they are different). But in the meantime I get used to this new approach and enjoy the views of KDE Plasma 5, I needed some help to the transition.

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

En muchas ocasiones, cuando tenemos que crear un servicio que pide usuario/password, tendemos al uso de passwords simples o poco elaboradas. Tanto si es para un uso personal como si es para compartir información entre usuarios (este, quizás, más importante aún securizar), las password simples o basadas en diccionarios no son del todo una buena idea.

Este pequeño script de python genera una clave de N caracteres aleatorios (pasados por argumento, o 10 en su defecto), que puede añadir símbolos indicando el argumento "@".

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import string,random,sys

dictionary = string.ascii_letters + string.digits
dictionary_extra = '@.-!~'
N = 10

if(len(sys.argv)>1):
	if(sys.argv[1][0]=='@'):
		dictionary += dictionary_extra
		if(len(sys.argv[1])>1):
			N=int(sys.argv[1][1:])
		else:
			N = int(sys.argv[1])
print ''.join(random.SystemRandom().choice(dictionary) for _ in range(N))

Ejemplos de uso:

$ python randompasswd @20
Dk5nl8w~.WxrkEj94!V~

$ python randompasswd @
0KAiU0z@rC

$ python randompasswd
eqUL9Kaw22G1QFc

Para automatizar tareas siempre había hecho uso de autoexpect, ya que, una vez realizado (y guardado) todo la primera vez, sólo había que hacer un par de apaños al script resultante. Sin embargo, hay veces que no necesitamos algo tan sofisticado o no queremos instalar tcl/tsh en la máquina.

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

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import subprocess
import time
import sys, getopt

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

def usage():
	print '''
		Usage: sendlines -f textFile -c "COMMAND" [ -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.
		'''
if __name__ == "__main__":
	textFile = None
	command = None
	delay = None
	try:
		opts, args = getopt.getopt(sys.argv[1:], "f:c:d:", ["file=", "command=", "delay="])
	except getopt.GetoptError as err:
		# print help information and exit:
		print str(err) # will print something like "option -a not recognized"
		sys.exit(2)
	for o, a in opts:
		if o in ("-f", "--file"):
			textFile = a
		elif o in ("-c", "--command"):
			command = a.split(' ')
		elif o in ("-d", "--delay"):
			delay = a
		else:
			assert False, "unhandled option"
			usage()
	if(command and textFile):
		run(command,textFile,delay)
	else:
		usage()
		print 'Missing argument(s). Exit\n'
		sys.exit(2)

Desde la versión 9.3, postgreSQL permite hacer dumps de la base de datos en forma paralela, aprovechando así el número de cores de la máquina.

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:

#!/bin/bash
## This script will create a backup for each database listed in the DATABASES variable
## Use as postgres user or add the -U [username] to the pg_dump line

DATABASES="template1 db other_db"
CORES=`nproc`
TARGET_FOLDER=/var/backups

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