Reproductor Grooveshark

Grooveshark es una solución muy interesante en la linea de Spotify, gratis de momento (a base de fastidiosa publicidad) y más liberal con los artistas que aparecen…

Dada su popularidad empiezan a aparecer programas para acceder a Grooveshark sin necesidad de navegador (para, por ejemplo, evitarnos la fastidiosa publicidad). Para Ubuntu, tenemos Gsharkdown, que además también permite descargarse las canciones…

Ubuntu puede reproducir música

En la serie de artículos “ubuntu-can” presentaremos las cosas que en un Mac son fáciles de hacer… y en Ubuntu también ^_^

iTunes tiene su manera de hacer las cosas, lo cual le ha creado muchos detractores. Pero… si le dedicas un tiempecillo a descubrir sus virtudes, no echas de menos a otros reproductores multimedia.

Ubuntu 11 ha elegido como sustituto de iTunes a Banshee. A veces es un poco lento, por eso merece la pena probar Rhythmbox (via Ubuntu Software Center). De hecho está más próximo a iTunes en su apariencia. y mantiene las funciones claves de iTunes:

  • Listas inteligentes (smart lists): permiten organizar tu música a tu gusto, agrupándolas en función de un conjunto de características (al estilo de una consulta en una base de datos). Por ejemplo, la clásica lista “Mis preferidas” no es más que una selección de las canciones cuya puntuación es de 4 estrellas o más. Mi lista “iPod Nano” contiene las canciones de mi lista “Música nueva y relajante” (canciones con etiqueta @relajante que  he añadido en los últimos 3 meses), mi lista “Favoritas Nano” (canciones con más de tres estrellas, limitada a 2GB) y mi lista “Pendientes Nano” (3 horas de música que aún no he escuchado). Como puedes comprobar, las posibilidades son infinitas. A Rhythmbox parecen faltarle algunos campos importantes, como “Skipped” y “Playlist”
  • “Explorador de columnas” (column browser): permite filtrar rápidamente por genero, artista o album.
  • Sincronización con iPod / iPhone: en Rhythmbox es un poco pobre, mejor usar gtkpod. Una ventaja de Ubuntu es que sus reproductores permiten rescatar archivos desde un iPod y sincronizar un iPod contra varios ordenadores (cosas que iTunes no permite) Puede leer incluso iPods formateados en un Mac (HFS plus), pero parece que escribir en ellos falla…
  • Extracción de audio desde CD (con la ayuda de Gstreamer)
  • Grabación de audio CD (con la ayuda de Brasero)
  • Detección de duplicados – aparentemente Bansheey Rhythmbox no tiene esta función 🙁
  • Obtener carátulas

Yes, U can

Obviamente tú puedes 😉 pero la U en este caso se refiere a… Ubuntu.

Las últimas versiones de OS X me gustan por su sencillez: funciona, es fácil y hasta tiene un diseño atractivo.

Pero… el universo Apple casi siempre tuvo una tendencia al monopolio y el control, restringiendo qué se puede hacer y con qué. Es lo que llaman “lock in”, o sea, los juguetes de Apple se llevan bastante bien entre sí pero no tan bien con la competencia. De modo que si un día decides dejar el universo Apple, puede costar bastante trabajo.

En cambio, al universo Linux le pasa lo contrario: tradicionalmente se ha primado la libertad, la variedad, la versatilidad… hasta el punto de que cualquier cosa por nimia que sea se puede hacer de 10 formas diferentes (lo cual puede crear un cierto estrés de decisión…) Pero… no siempre fue facil, simple ni con diseño atractivo.

Ubuntu ha tomado también la senda de la dominación mundial :-p (como ya hicieran Microsoft y Apple). Mientras lo consigue y mientras respete el espiritu libre de la comunidad Linux, esa actitud tiene sus ventajas… ¿Que Apple es simple, bonito y fácil? Pues… ¿por qué no tomar prestadas sus buenas ideas? Al fin y al cabo, las tripas de OS X aprovechan bastante código Open Source (BSD, Cups…)

De entrada Ubuntu es la opción más económica (argumento de peso en estos tiempos de crisis…) Ubuntu es gratis y se puede instalar prácticamente en cualquier PC. Windows 7 también funciona en muchos PC, pero su licencia más cutre sale por 120 euros (octubre 2011). La Ultimate, por 320 eurillos. Mac OS X cuesta entre 30 y 60 euros. Pero Hackintosh aparte, solo funciona en ordenadores Apple, que si bien suelen ofrecer una alta calidad, baratos no son precisamente.

Por lo tanto, Ubuntu se está convirtiendo en una buena alternativa a Mac OS X… que a su vez es una buena alternativa a Windows.

En esta serie de artículos etiquetados “ubuntu-can” iremos desglosando las cosas buenas que se pueden hacer con Ubuntu.

Comenzamos

Atajos teclado tmux

Tmux, reencarnación moderna de screen digna de ser probada.

Los atajos deben precederse con Control-b (puede cambiarse, por ejemplo al clásico Control-a de screen).

Por ejemplo, para cambiar de panel (atajo “o”), tendríamos que teclear “Control-b o”

Algunos atajos interesantes que vienen “de serie” son…

? “ayuda” (lista de atajos en uso)
c crear ventana
% dividir ventana actual en dos paneles verticales
número ir a ventana (por número 😉 )
, renombrar ventana actual
[ cambiar a modo selección (según modo de edición. Por defecto, )
] pegar lo copiado en el modo selección (por defecto, “copiar y pegar” sólo funciona “localmente”, es decir, entre sesiones de tmux en un mismo ordenador)
p / n ventana anterior / siguiente
o siguiente panel
; último panel
q lista de paneles (se puede elegir uno tecleando su número)
z “maximizar” panel (zoom)
M-cursor cambiar tamaño panel
M-1..M-5 Elegir distribución: equitativa horizontal (1) o vertical (2), en celdas (5)
espacio cambiar disposición paneles ventana actual (horizontal/vertical)
w lista de ventanas.
r redibujar
& matar ventana actual
d desconectar de la sesión tmux (se puede reconectar ejecutando tmux attach)
: prompt para ejecutar comandos, por ejemplo source-file ~/.tmux.conf (recargar configuración después de modificarla)

Para usar el portapapeles de las X, hace falta añadir en ~/.tmux.conf algo del estilo…

# "pegar" desde portapapeles X a buffer tmux
bind C-y run "tmux set-buffer \"$(xclip -o)\"; tmux paste-buffer"

# "copiar" desde buffer tmux a portapapeles X

# opción A: usar C-b C-w para copiar al portapapeles lo que se ha copiado en el "modo copia"
# con "xclip -i", tmux deja de responder al prefijo...
# bind C-w run "tmux save-buffer - | xsel -i -b"

# opción B: dentro del "modo copia", reutilizar el atajo M-w para copiar en el portapapeles X
bind -t emacs-copy M-w copy-pipe "xsel -i -b"

xclip por defecto usa el portapapeles “primario” (el de el botón medio del ratón), por eso si queremos usar el portapapeles “moderno” (el de “Control-C Control-V”) hay que especificárselo con “-selection c”. Más sobre xclip…

Sugerencia: usar xsel en vez de xclip con tmux

Los atajos se pueden definir en la tabla global, con “bind”, o en una tabla en concreto, con “bind -t”

Fn + F7 no funciona en Linux

Activar la salida de monitor o apagar la pantalla del portátil requiere de la intervención del servidor X, bien a través de la extensión Xrandr o bien a través del controlador nativo. Por ejemplo, en el caso de tarjetas ATI se recurriría al comando aticonfig

Si XRandr está activado, se pueden ejecutar los siguientes comandos:

 

xrandr -q
# muestra un listado de los monitores disponibles. Normalmente, la 
# pantalla del portatil (LVDS) y el monitor externo 
# (CRT1 o VGA) si está conectado.
# Apagar pantalla P
xrandr --output P -off

# Encender de nuevo la pantalla P
xrandr --output P --auto

Las últimas versiones de distribuciones como Ubuntu ya integran esa funcionalidad, y lo que hacen precisamente es llamar a estos comandos cuando el usuario pulsa el atajo Fn + F7

xrandr también soluciona el problema de que en Ubuntu, con la pantalla configurada en modo mirror, el monitor externo use una resolución inferior a la máxima. Por ejemplo, si el monitor se identifica como VGA1:

xrandr --output VGA1 --mode 1680x1050

Al cambiar la resolución, puede que el escritorio siga en la resolución anterior, ya que la pantalla del portátil seguramente no alcance la resolución que hemos puesto a la externa. La solución más simple es desactivar la pantalla del portátil (en este ejemplo, LVDS1):

xrandr --output LVDS1 --off

Los cambios se pueden hacer “permanentes” en el fichero /etc/gdm/Init/Default

Debian USB para EFI y BIOS

La idea es poder arrancar / instalar Debian desde un pendrive (llave / pincel USB) tanto en ordenadores con arranque BIOS (clásico de PCs y compatibles) como con arranque EFI (el supuesto futuro, por ahora casi exclusivo de ordenadores Mac Intel)

En “Cómo crear un USB con Ubuntu Live para Mac y PC” proponen un método que aprovecha la emulación BIOS de los microcódigos de algunos Mac, por lo que es propenso a fallos (por ejemplo, “Error: Not found while loading legacy loader”). La alternativa es integrar un gestor de arranque EFI, por ejemplo Grub2, como plantean en “Testing on UEFI

Todos los ficheros (grub, live cd, etc) deben ser para la arquitectura del ordenador en el que se va a usar (por ejemplo, amd64)

PASOS EN LINUX

Particionar el pendrive (por ejemlo, /dev/sdb)

sdb1: ext3 (en fdisk 82) –  32 MB (para que quepa el directorio boot del live cd)
sdb2: HFS+ (en fdisk AF) – 16MB
sdb3: FAT32 (en fdisk, b), activa (boot) – resto espacio disponible

Crear los sistemas de ficheros ext3 y FAT32 con mkfs

Montar la imagen filesystem.squashfs para poder copiar en sdb1 el directorio boot que contiene

Instalar grub2 en el MBR del pendrive, usando como directorio raiz el sistema de ficheros ext3 (sdb1)

grub-install --root-directory=/mnt/sdb1 /dev/sdb

Copiar los ficheros del Live-CD de Debian al sistema FAT32. En el live CD, los ficheros de arranque son /live/vmlinuz y /live/initrd.img (esto es importante para configurar el grub, ver más abajo)

PASOS EN MAC

Formatear la partición HFS+ (disk2s2 en Mac) con Disk Utility

Copiar la carpeta efi (dentro del paqute refit .dmg) a la partición HFS+

Ejecutar como superusuario el script efi/refit/enable.sh.

sudo enable.sh

Este script instala refit en el pendrive, con lo que la tabla de particiones pasa a formato GPT

Al arrancar el Mac, dejar pulsada la tecla Alt para que permita elegir el dispositivo de arranque. Elegir el pendrive.

Una vez en grub, configurar el arranque a mano:

root (hd0,3)
linux /live/vmlinuz boot=/live live-config
initrd /live/initrd.img
boot

El autologin debería estar activado (gracias al parámetro live-config). En caso de que pregunte por usuario y clave, usar user y live.

Ejecutar el instalador (debian-installer)

Se puede consultar documentación sobre configuración del linux live en las páginas live-boot y live-config (usando man)

Para instalar Debian desde el Live-CD se está desarrollando el paquete live-installer. Otra forma de instalar Debian desde USB es copiando los ficheros de un disco de instalación, por ejemplo netinst. En este caso los ficheros son install.amd/vmlinuz e install.amd/initrd.gz (una vez definida la raiz con root, se puede ejecutar ls para buscar esos ficheros)

Otras distribuciones como Fedora permiten crear un pendrive de instalación UEFI directamente

Enlaces de interés:

Manual de Debian-Live

GPT

Linux en Apple Xserve

Depurar codigo Java JNI en Linux

Depurar una mezcla de código Java y C++ no es trivial, sobre todo porque aún no hay disponibles entornos (o plugins) estables que soporten esta posibilidad. Con lo cual hay que recurrir a la siguiente receta, que permite interactuar a la vez con los depuradores nativos de cada lenguaje (sean para consola como gdb, o gráficos como NetBeans)

Primero iniciar el programa en modo de depuración remota:

java -Xdebug -Xnoagent -Djava.compiler=none -Xrunjdwp:transport=dt_socket,server=y,suspend=y -Djava.library.path=$LD_LIBRARY_PATH -cp . -jar PROG.jar
Listening for transport dt_socket at address: 37112

Es importante definir java.library.path para que contenga el directorio donde se encuentra la biblioteca .so con el código nativo (en este caso, se le asigna el valor de la variable de entorno LD_LIBRARY_PATH).

Iniciar el depurador de Java y conectarse al puerto indicado por el comando anterior (en el ejemplo, 37112)

jdb -attach 37112

También se puede utilizar un depurador gráfico, por ejemplo el que viene con Eclipse. Para ello basta crear un perfil de depuración de tipo “Remote Java Application”. En Connection Properties usar localhost y como puerto el que nos devolvio el anterior comando java (siguiendo con el ejemplo, 37112)

Establecer el punto de parada en el código Java

stop at CLASE:NUM_LINEA
run

Una vez alcanzado el punto de parada en el código Java, iniciar el depurador de código nativo y vincularlo con el proceso java mediante su PID

gdb
attach PID
break JNI_FUNCTION

continue (retoma la ejecución del programa java)

Importante: para que el depurador C++ encuentre la función JNI, el programa Java debe tener ya cargada la biblioteca C++ (archivo .so). Si paramos la ejecución del programa Java demasiado pronto, cuando entremos en el gdb la biblioteca aún no se habrá cargado y por lo tanto al intentar el “break” se quejará de que no encuentra la función.

Estos tres comandos gdb también pueden ejecutarse dentro de ddd, lo cual nos permite depurar el código C++ con la comodidad de un entorno gráfico

Por último, de vuelta en jdb ejecutar run de nuevo (continua la ejecución en el depurador y se detiene en el breakpoint del código nativo definido en gdb)

Configuración interfaces de red en Debian

# The loopback network interface
auto lo
iface lo inet loopback

# interfaz principal
auto eth0
iface eth0 inet dhcp

auto eth1
iface eth1 inet static
        address 192.168.33.34
        netmask 255.255.255.0
        network 192.168.33.0
        broadcast 192.168.33.255
        gateway 192.168.33.1
        # dns-* options are implemented by the resolvconf package, if installed
        dns-nameservers 192.168.33.1 8.8.8.8
        dns-search my.domain.com

Mis Linux favoritos

Una pequeña selección de distribuciones Linux, en función de su utilidad

  • propósito general: Open SUSE o Ubuntu
  • servidores: Debian
  • arranque y rescate: Knoppix (Live CD)
  • eficiencia (si tienes paciencia :-p ): Gentoo
  • otras:
    • CoLinux (run Linux inside Windows with no virtualization)
    • dsl y puppy: distribuciones minimas que caben en cualquier sitio

Y algunos enlaces para ir abriendo boca con Linux

Awk

Límites numéricos de awk: mawk parece que tiene la impresión de enteros limitada a 32 bits con signo, mientras gawk no:

> mawk '{a=11111111111111111111+10; printf "%d", a}'
2147483647
> gawk '{a=11111111111111111111+10; printf "%d", a}'
11111111111111110656

En general, la aritmética de awk es en IEEE double (de ahí el error en la suma al pasar a enteros)

> mawk '{a=11111111111111111111+10; print a}'
1.11111e+19
> gawk '{a=11111111111111111111+10; print a}'
11111111111111110656

Observamos también que por defecto gawk evita el formato científico para imprimir enteros.

Bash

Aspectos básicos

“Depurar” código bash

Lo más directo es habilitar las trazas mediante el parámetro -x de bash (equivalente a la opción xtrace). Se puede refinar definiendo algunas variables:

# xtrace -> imprimir trazas
set -o xtrace
# version abreviada de la linea anterior
set -x
# noglob -> impedir el procesamiento de metacaracteres en nombres de fichero ("globbing")
set -o noglob
set -f  
# verbose -> imprimir las líneas de código según se van leyendo
set -o verbose 
set -v  
# nounset -> abortar al intentar usar una variable no definida
set -o nounset
set -u
# cambiando la variable PS4 se puede personalizar las trazas. Por ejemplo, añadir el número de línea
export PS4='+(${BASH_SOURCE}:${LINENO}): ${FUNCNAME[0]:+${FUNCNAME[0]}(): }'

Variables

Valores por defecto: con “:-” se asigna el valor a la variable. Con “:=” simplemente se retorna el valor por defecto (cuando la variable no tiene valor), esto es, no se modifica la variable.

login="pepe"
export login="pepe"
echo ${login}
echo ${login:=login no definido}
echo ${login:-invitado}

Cadenas

linea="tres tristes"
linea+=" tigres"
echo ${linea}

# Subcadenas
${linea:posicion:longitud}
${linea: -posicion:longitud} # ojo al espacio antes de "-", es importante

# Eliminar subcadenas
f="/usr/lib/libkewl.so" 
# borrar por el principio
${linea#*/}  # elimina la subcadena de menor longitud, comenzando por el principio
${linea##*/} # elimina la subcadena de mayor longitud
# borrar por el final
${linea%/*}  # elimina la subcadena de menor longitud, comenzando por el final
${linea%/*}  # elimina la subcadena de mayor longitud, comenzando por el final

# Sustitucion
${linea/patron/sustitucion} # primera aparicion
${linea//patron/sustitucion} # todas apariciones

# Longitud cadena
${#string}
expr length $string

# tests con cadenas
# cadena vacia / no vacia
[ -z "${s1}" ]  # cadena vacia
[ -n "${s2}" ]  # cadena no vacia

# Pertenencia
[[ "${linea}" == *tristes* ] ]

# Split / join
# usando sustitución
readonly DIR_SEP="/"
array=(${f//${DIR_SEP}/ })
second_dir="${array[1]}"
# usando IFS
hora="HH:MM:SS"
IFS=":" read -ra campos <<< "${hora}" 
# Para agrupar palabras en una linea (por ejemplo, con nombres que incluyen espacios), cambiar el separador IFS a \n (escapandolo con $):
IFS=$'\n'

Control de flujo

Condiciones: dentro de [ ] para seguir el estándar POSIX (“clásico”). Para usar las bondades de la extensión del estándar, meter la condición dentro de [[ ]].

También se puede comparar directamente el código de retorno (sin corchetes)

Operadores “clásicos”:

  • ==, != comparacion cadenas, -z longitud cero, -n longitud no cero
  • -f fichero, -d directorio, -r lectura, -w escritura, -x ejecutable
  • -eq -gt -lt -ne -ge -le: comparacion numerica

Operadores de la extensión del estándar:

  • =~ expresiones regulares
if [ cond ]; then
        b1
elif [[ "${linea}" == *tristes* ] ]; then
        b2
elif grep -qF "string" file; then
    echo 'file contains "string"'
else
        b3
fi

for x in SECUENCIA; do
   echo $x
done

case PATTERN in
        p1)
        ;;
...
        pm)
        ;;
        *)
        ;;
esac

Aritmética

Tradicionalmente se hacían con expr o bc, pero hoy en día suele ser más práctico usar los “dobles paréntesis”:

(( a ++ ))
(( x = a>3?1:0 ))

# si queremos hacer la asignación fuera de los dobles paréntesis,
# hay que añadir un dolar:
Z=$(( x + 4 ))

# número aleatorio
x=$RANDOM

# módulo
let "x %= 100"

Límites numéricos de bash (ver también los límites de awk)

Vectores (arrays)

Empiezan en 0

#operaciones basicas
a[3]=X
echo ${a[3]}
# longitud
${#arrayname[@]}
# se puede crear un array facilmente con ():
a=(1 2 3 4)

Se puede asignar tal cual una “lista” separada por espacios:
declare -a nombres
nombres=(paco pablo pato)

Esto se puede combinar con la sintaxis “salida de un comando”, $(), para llegar al combo ($( )):

nombres=($(ls))

Patrón “lista de directorios”

for d in $(ls -d */); do
...
done

Patrón “glob” (operar recursivamente partiendo de un directorio)

find d -exec cmd1 {} \; -exec cmd2 {} \;

Patrón “fichero de configuración”

En bash, es preferible escribir el fichero de configuración en bash y “cargarlo” con source (o su abreviatura, “.”), a usar otra sintaxis y tener que parsearlo como texto…

Patrón “procesamiento de patrones”

Con el operador =~ es bastante simple:

# para no tener que escapar la expresion regular, lo mejor es meterla en una variable
my_regex="([[:alpha:][:blank:]]*)- ([[:digit:]]*) - (.*)$"

if [[ "$CDTRACK" =~ ${my_regex} ]]; then
        echo Track ${BASH_REMATCH[2]} is ${BASH_REMATCH[3]}
        mv "$CDTRACK" "Track${BASH_REMATCH[2]}"
fi

# BASH_REMATCH contiene los emparejamientos de la ultima expresion regular

Patrón “diccionario”

Los diccionarios se conocen en bash como “arrays asociativos”

# -A -> array asociativo
declare -A rutas
rutas[pepe]="/users/g1/pepe"
clave="pepe"
echo ${rutas[${clave}]}
rutas=([marcos]="/users/g1/marcos")
rutas+=([lucas]="/users/g3/lucas")
# asignación múltiple
rutas([pedro]="/users/g2/pedro" [antonio]="/users/g1/antonio")
# clave con espacios
rutas["jose luis"]="/users/tic/jl"
echo ${rutas[antonio]}
ruta=${rutas[antonio]}
# todos los valores
echo ${rutas[@]}
# todas las claves
echo ${!rutas[@]}

# patrón "imprimir diccionario"
for usuario in "${!rutas[@]}"; do
    echo "${usuario} ${rutas[$user]}"
done

Redirecciones

Redirección básica: salida (“>”), entrada (“<") Añadir: ">>”

“Triple redireccion”: pasa una cadena por la entrada estándar

echo 1234X-D | sudo joe -c “passwd”
sudo joe -c “passwd <<< 1234X-D" Usar procesos en vez de ficheros (Process substitution) Con <() se conecta la entrada estándar de un comando con la salida estándar de los comandos dentro de los paréntesis. Sustitución de comando por su salida: [code] # clasica FILES=`ls` # contemporanea en linea. Ventajas: se pueden anidar varias FILES=$(ls) # contemporanea a array (Asignar el resultado a un array) FILES=($(ls)) [/code] # Añadir una cabecera a una lista para que column formatee la cabecera y la lista column -t <(echo "Permisos i user group count fecha hora nombre") <(ls -l | sed 1d) # Opciones: >() o <() (sin espacio entre el < o el > y los parentesis)
comm <(ls -l) <(ls -al)

“Punteros”

p=x
x=2
# Imprime x
echo $p
eval p=\$$p
# Imprime 2
echo $a

Paralelismo

El clasico “&” y los coprocesos (coproc)

Expresiones estilo C

# Solo operacion (no se usa el valor de retorno)
(( a = 20 )) # mantener todos los espacios
(( a ++ ))
(( x = a>3?1:0 ))
echo $x # imprime 1
# Para valor de retorno hay que añadir $
Z=$(( x + 4 ))

Patrón “procesar parámetros”

* Procesar parametros del script con getopts
# El primer parametro es la lista de switches que se aceptan, un “:” despues de una letra indica que ese
# switch acepta un parametro, por ejemplo -b hola
while getopts “:ab:cd” Option
do
case $Option in
b) echo “b” parameter is $OPTARG

esac
done

* Secuencias de números
for i in `seq 1 20`…
for i in {1..20}…
# Con ceros delante
for i in `seq -f %03.0f 1 10`…
for i in `printf ‘%03d ‘ {0..123}`…

Proceso de texto

Leer líneas

Bash FAQ 001

read / mapfile / readarray

cat fichero | while read -r linea; do
   echo "${linea}"
done
# fuera del bucle, la variable linea no está accesible
echo ${linea}

# readarray funciona como un alias de mapfile
declare -a lineas
mapfile lineas < fichero
echo ${lineas[1]}

En ambos casos, ojo con las subshells

Patrón “leer columnas”

# con read
# ojo: como las tuberías crean subshells, 
# no se puede acceder desde fuera del bucle a las variables leidas...
cat fichero | while read C1 C2 C3; do
   echo $C2
done

Declarando una variable como array, es “facil” sacar los campos de una linea en bash:

declare -a TEST
TEST=(a b c d)
echo ${TEST[0]}
# a
TEST=(1 b c d)
echo ${TEST[0]}
# 1
# Con triple redireccion:
read C1 C2 <<< "Campo1 Campo2"
# O bien, usar la redireccion simple, en lugar de un pipe:
while read C1 C2; do .... done < fichero

Curiosidades

Hidden features of bash

Mis favoritas:

  • Alt + . (último parámetro)
  • ${SECONDS}
  • ${RANDOM}
  • TMOUT

Operaciones con conjuntos en shell

Bash one-liners

Página principal GNU Bash

Bash hackers Wiki

Bash FAQ (en “Greycat’s Wiki”)

Documentación sobre Bash en StackOverflow Documentation

sed

Expresiones regulares en sed: para usarlos como metacaracteres, hay que “escapar” +, (, ), ?

“ak* \+xx\?” -> “akkk xx3”

Sustitución reutilizando el patron

# Caso sencillo: 1 solo patron. Se puede usar &:
# Añadir parantesis a cada secuencia de numeros
sed 's/[0-9]*/(&)/'

# Para varios patrones, se marcan los patrones a reutilizar con parentesis,
# y se utiliza \1, \2 para referenciar cada patron encontrado:
# Intercambiar el primer campo con el segundo. Por ejemplo, Type: abc-123 se convierte en Type: 123-abc
sed 's/Type: \([a-z]*\)-\([0-9]*\)/Type: \2 \1/'
# Elimina el path de una url, dejando solo hasta el hostname
sed "s_\(http://[a-z0-9A-Z.\-]*/\)\(.*\)_\1_"

Extraer cadenas de una linea

Con egrep (grep -E) se puede imprimir la parte de una linea que coincida con un patron.

Por ejemplo, para extraer las temperaturas de una linea…

echo "Temp1: 37.2 C Temp2: 40.0 C" | grep -Eo '[0-9\.]+[[:punct:]]?[ ]?[CF]+'

Inserción de texto

# Añadir texto al final de una linea
sed '/^wheel/ s_$_,newWheelUser_' /etc/group

Con i inserta un texto antes de la linea actual, con a despues. En ambos casos introduce un salto de linea. Por eso, para que inserte en la misma linea hay que recurrir a la sustitucion:

> sed iabcd
  fge
  abcd
  fge
> sed aabcd
  geg
  geg
  abcd
> sed s/^/abcd/g
   geg
   abcdgeg

# Añadir una linea al final de varios ficheros de texto
sed -i '$aexit 0' *
# Añadirla al principio (con salto de línea 😉
sed -i '1i. /home/group-bashrc\n' /home/*/.bashrc

Para ejecutar varios comandos sed en una línea, separar con “;”

sed "s/NODE/$NODE/g;s/IP/$IP/g" < $TEMPLATE

UNIX Stream EDitor (sed) Cheat Sheet

Reinstalar grub a mano

Puede ocurrir que perdamos el arranque de grub (por ejemplo, al instalar Windows después de Linux). Algunas distribuciones incluyen entre las opciones de sus discos de instalación la opción “rescate” (Rescue), dentro de la cual puede aparecer la recuperación automática de Grub.

Arrancando desde un Live CD, también se puede reinstalar grub “manualmente”:

  1. Montar la partición raíz (por ejemplo, en /mnt/linux)
  2. Ligar los sistemas de ficheros /dev, /proc y /sys dentro de /mnt/linux (usando “mount -o bind”)
  3. “Teletransportarnos” a /mnt/linux con “chroot /mnt/linux” (una de las múltiples chuladas de Linux ^_^)
  4. Instalar grub: “grub-install /dev/sda” (suponiendo que ese sea el disco duro en el cual queremos instalarlo)

Screen

Combinaciones útiles:

# Por defecto, la tecla de "llamar la atención" de screen es Control-a (abreviado ^a)
# Ayuda
^a ?
# crear ventana
^a c
# cambiar a la siguiente ventana
^a^n
#  cambiar a la ventana anterior
^a^p
# cambiar a la ventana enésima (0<= N <= 9)
^a N
# desconectar de sesion
^a d
# cerrar todas las ventanas y salir
^a ^\
# mostrar sesiones activas
screen -ls
# reconectarse a una sesion
screen -r id_sesion
# Cambiar el título de la ventana
^a A
# Mostrar información
^a i
# Ir al principio de la línea :-p
^a a