Subscription Options:

Twitter

Calendar

September 2010
S S M T W T F
« Jul    
 123
45678910
11121314151617
18192021222324
252627282930  

Recent Comments

Blogroll

RSS Twittero HG Repository

Jul
16.
Bateria baja
1 Comentario
Categoria: Uncategorized

Necesitaba algo que me avisara en X cuando la bateria de mi laptop estuviera por agotarse. Uso Fluxbox, y no encontraba ningún applet para poder hacer esto, utilizaba frecuentemente ibam para verificar como estaba de bateria, pero no era demasiado comodo, así que pense ¿y si hago un script que me avise?, y si lo hise.
Para poder utilizarlo tienen que tener instalado ibam y awk, en ArchLinux:

#: pacman -S ibam gawk

La idea es que esto se ejecute (para verificar), cada 3 minutos, asi que lo cronie (asegurarse de que el demonio cron se inicie).

$: crontab -e


Y agregue algo como esto (donde */3 son los minutos entre ejecución):

*/3 * * * * /home/_tty0/bin/battery


El script en cuestión es el siguiente:

#!/bin/sh
percentage=10

total=`ibam -a | grep Charge\ percentage | awk {'print $3'}`
 time=`ibam -a | grep Battery\ time | awk {'print $4'}`

if [[ $total -le $percentage ]] && [[ `cat /proc/acpi/battery/BAT0/state | grep discharging | awk {'print $3'}` == 'discharging' ]]; then
  zenity --display=:0 --error --timeout=20 --title="AVISO: Bateria baja" --text="Bateria baja - Tiempo de carga restante: ${time}"
  echo 40 > /proc/acpi/video/OVGA/DD03/brightness
    if [[ $total -le 2 ]]; then
      zenity --display=:0 --question --title="AVISO: Batería demasiado baja" --text="Bateria demasiado baja. ¿Desea hibernar?.\n Tiempo de carga restante: ${time}" \
      && echo sudo pm-hibernate
    fi
fi

exit $?

Básicamente, el porcentaje al mostrar el aviso se puede modificar editando la variable PERCENTAGE, en este caso, nos avisara con un mensaje en las X, cuando la bateria sea igual o menor al 10%.
Espero que a alguién le sirva. Saludos!.

Tags: , , , , , , , , , , , ,
Jun
26.
Hello world
7 Comentarios
Categoria: Uncategorized

La verdad que estaba aburrido, y me puse a hacer el clásico “Hello world” en distitnos lenguajes!.
En Awk:

#!/bin/awk -f
BEGIN{
print "Hello world";
}

En Bash:

#!/bin/sh
echo "Hello world"
exit $?

En Basic:

10 PRINT "Hello world"
20 EXIT

En ANSI C:

#include <stdio.h>

int main() {
     printf("Hello world\n");
     return 0;
}

En Ensamblador Intel x86:

SEGMENT .text
  mov eax, 4          ; put syscall - write (4) - in EAX
  mov ebx, 1          ; put stdout (1) in ebx
  mov ecx, decir      ; put in edx the string (db decir)
  mov edx, 13         ; put in edx the size_t len
  int 0x80            ; change to kernel mode

  ; EXIT
  mov eax, 1          ; put syscall exit (1) in EAX
  mov ebx, 1          ; put the int status in ebx
  int 0x80            ; change to kernel mode 

  db decir 'Hello world', 10, 27

En HTML

<html>
<head><title>Hello world</title></head>
<body>
<p>Hello world</p>
</body>

En JavaScript:

<script type="text/javascript">
document.write("Hello world");
</script>

En PHP

<?php echo 'Hello world!'; ?>

En Python:

#!/usr/bin/env python
print "Hello world"
exit()

En Ruby:

#!/usr/bin/ruby
print "Hello world\n"
exit()

Tags: , , , , , , , , , ,
Nov
19.
Powering Zsh, powering your shell
1 Comentario
Categoria: Uncategorized

Ya es sabido que mi shell favorita en Unix por estos tiempos en  Zsh, una shell muy versatil, configurable y algo que me agrada demasiado es su autocompletado inteligente y el right prompt.
En este texto vamos a tratar algunos trucos o tips para Zsh, los cuales espero que les resulten más que util.

1-Cambiar la shell por defecto de nuestro usuario a Zsh

Esta es una taréa mas que facil, lo que debemos hacer es modificarlo el shell que inicia el usuario en el archivo /etc/passwd, para ello con nuestro editor de textos favoritos (recomiendo Vim), abrimos el archivo /etc/passwd.

gnats:x:41:41:Gnats Bug-Reporting:/var/lib/gnats:/bin/sh
nobody:x:65534:65534:nobody:/nonexistent:/bin/sh
facundo:x:1000:1000::/home/facundo:/bin/bash
libuuid:x:100:101::/var/lib/libuuid:/bin/sh
messagebus:x:101:103::/var/run/dbus:/bin/false

Como primer punto, localizamos a nuestro usuario, en mi caso facundo, y remplazamos el shell /bin/bash por /bin/zsh quedando de la siguiente manera:

gnats:x:41:41:Gnats Bug-Reporting:/var/lib/gnats:/bin/sh
nobody:x:65534:65534:nobody:/nonexistent:/bin/sh
facundo:x:1000:1000::/home/facundo:/bin/zsh
libuuid:x:100:101::/var/lib/libuuid:/bin/sh
messagebus:x:101:103::/var/run/dbus:/bin/false

Una vez listo, guardamos los cambios y salimos del editor de textos, la próxima vez que nos loguiemos en el sistema, iniciaremos con Zsh :) .

2-Dandole color a nuestro prompt

El prompt es la llamada del sistema que vemos en la shell, la cual nos dice que esta a la espera de comandos, generalmente tiene un aspecto un poco “feo”, algo similar a esto [facundo@tty0:~], sin colores, poco atractivo, etc. Cabe destacar que para poder realizar esto necesitamos una terminal ANSI.

Esta tarea no es dificil, pero si algo mas tediosa, ya que ir provando color por color, es algo molesto, por lo cual recomiendo el siguiente script, para conocer bien los codigos de los colores.

#!/bin/bash
T='gYw'   # The test text

echo -e "\n                 40m     41m     42m     43m\
    44m     45m     46m     47m";

for FGs in '    m' '   1m' '  30m' '1;30m' '  31m' '1;31m' '  32m' \
          '1;32m' '  33m' '1;33m' '  34m' '1;34m' '  35m' '1;35m' \
          '  36m' '1;36m' '  37m' '1;37m';
 do FG=${FGs// /}
 echo -en " $FGs 33[$FG  $T  "
 for BG in 40m 41m 42m 43m 44m 45m 46m 47m;
   do echo -en "$EINS 33[$FG33[$BG  $T  33[0m";
 done
 echo;
done
echo

Bien, lo primero seria salvarno en algún archivo de textos y darle permisos de ejecución al mismo.

chmod +x color.sh

Y para ejecutarlo simplemente hacemos: sh color.sh
Notaremos que los colores se expresan en codigos númericos, los que terminan en 0, son fuentes normales, los que terminan en 1 en negrita.

Bien, luego de esta aburrida introducción a los colores, tenemos que saber que el prompt se almacena en una variable global llamada PS1, esta variable va a contener todas las directivas que le pasemos a nuestro prompt.
Podemos verificar esto haciendo:

echo $PS1
${debian_chroot:+($debian_chroot)}\u@\h:\w\$

Bien, esto tiene menos onda que pelo lasio, por lo cual vamos a empezar a configurar nuestro prompt en Zsh, por lo cual, veamos algunas directivas primero:

Sequence Printed
%T System time (HH:MM)
%* System time (HH:MM:SS)
%D System date (YY-MM-DD)
%n Your username
%B - %b Begin - end bold print
%U - %u Begin - end underlining
%d Your current working directory
%~ Your current working directory, relative to ~
%M The computer's hostname
%m The computer's hostname (truncated before the first period)
%l Your current tty

Bien si por ejemplo ponemos %n@%d: nos mostrara (en mi caso): facundo@/path/:, a travez de estos operandos podemos ir definiendo nuestro prompt del sistema.

Bien ya teniendo las "directivas" de configuración y los codigos de los colores, podemos llegar a obtener algo como esto:

Zsh running over rxvt-unicode

Zsh running over rxvt-unicode

Lo cual no es otra cosa que el siguiente contenido en la variable global PS1:

$'%B%n%{\e[1;32m%}<%{\e[1;37m%}at%{\e[1;32m%}%B>%{\e[1;37m%}%M (%{\e[1;32m%}%~%{\e[1;37m%})%{\e[1;32m%}->%{\e[0;37m%}%b '
export RPS1="[%T]"

El sistema incorpora este contenido a sus variables globales a través del comando export.
Por lo cual si queremos utilizar este prompt, como en mi caso, solamente abriremos con Vim, el archivo /etc/zsh/zshrc e incorporaremos lo siguiente:

export PS1=$'%B%n%{\e[1;32m%}<%{\e[1;37m%}at%{\e[1;32m%}%B>%{\e[1;37m%}%M (%{\e[1;32m%}%~%{\e[1;37m%})%{\e[1;32m%}->%{\e[0;37m%}%b '
export RPS1="[%T]"

También podremos hacer esto modificando nuestro ~/.zshrc y tarea terminada.

3-Activando el right prompt

El procedimiento es exactamente que en el caso anterior, solo que trabajaremos sobre otra variable, la variable global RPS1, por lo cual nuevamente en el archivo /etc/zsh/zshrc o en nuestro ~/.zshrc añadiremos el siguiente right prompt que nos muestra la hora actual:

export RPS1="[%T]"

4-Cargando alias con un archivo externo

Tengo la costumbre de usar una gran cantidad de alias en mi sistema, y de tenerlos a todos aislados en archivo con el siguiente formato:

alias dfh='df -h | ccze'
alias dir='ls --color=auto --format=vertical'
alias informe='/usr/local/bin/informe; pager /var/www/informe.txt'
alias l='ls -CF'
alias la='ls -A'
alias ll='ls -l'
alias ls='ls --color=auto'

En este archivo que yo he llamado .alias (es oculto), se guardan todos los alias que utilizo para ahorrar algunas líneas en la utilización del CLI. para llamar de Zsh a un archivo externo, podemos nuevamente modificar el archivo /etc/zsh/zshrc o en nuestra home el archivo ~/.zshrc
E incorporar el path hacia nuestro archivo con alias, poniendo delante del path un . (punto), el cual es solo un comando de Unix, el cual lo carga a modo de "libreria".
Por ejemplo en mi caso:

. ~/.alias

Ya que el archivo .alias se encunetra en mi home.

5-Quote of day

Una caracteristica simpatica de nuestra shell es poder utilizar un quote of day, que no es nada más que una cita de alguna frase, para hacerlo tenemos que instalar fortunes.
Para ello en el shell:

#: apt-get install fortunes fortunes-mod fortunes-es

Bien, una vez listo esto (¿notaron que instalamos fortunes en español?), con nuestro editor de textos favorito (vuelvo a citar a Vim), editamos el archivo /etc/zsh/zlogin, el cual contiene todas aquellas directivas que desean ser ejecutadas unicamente luego de realizado el login al sistema y por unica vez.
En este archivo añadimos algo como esto:

echo "Quote of day: $(/usr/games/fortune -s)"

Y listo, la proxima vez que nos loguiemos, tendremos a fortunes dandonos una cita :) .
Bueno esto es todo por hoy, espero que les halla gustado.

Tags: , , , , ,
Sep
15.
Bucles for y while en Bash y Python
2 Comentarios
Categoria: Uncategorized

En este breve post, mostraré, algunos bucles for en Bash y en Python, son simplemente para mostrar la construcción de ambos de una manera comparativa entre si mismos.

En Bash:
Caso Nº1: Imprimir secuencia númerica del número 1 al 10.

#!/bin/bash
for i in seq `1 10`; do
        echo $i
done

Caso Nº2: Imprimir STOUT de comando ls.

#!/bin/bash
for i in $(ls); do
        echo item: $i
done

Caso Nº3: Imprimir secuencia númeria del 10 al 0

#!/bin/bash
for i in {10..0}; do
        echo $i
done

Y este ultimo también se puede hacer con un while:

#!/bin/bash
A=10
while [[ $A > 0 ]]; do
        let A=$A-1
        echo $A
done

Las mismas construcciones en Python:
Caso Nº1: Imprimir secuencia númerica del 1 al 10.

#!/usr/bin/python
for i in range(1,10):
        print i

Caso Nº2: Imprimir STDOUT de comando ls.

#!/usr/bin/python
import os
for i in os.system("ls"):
        print i

Caso Nº3: Imprimir secuencia númerica del 10 al 0.

#!/usr/bin/python
lista=range(10)
lista.reverse()
for i in lista:
        print i

Y a este ultimo, también lo podemos realizar con while:

#!/usr/bin/python
A=10
while A > 0:
       A=A-1
       print A

Tags: , , , , ,
Jun
17.
Script para tomar instantaneas
2 Comentarios
Categoria: Uncategorized

script en Bash que toma instantaneas de nuestro desktop, utilizando el programa scrot, el cual podemos instalar mediante nuestro repositorios, para ello en una terminal:

#:apt-get install scrot

Luego el script en cuestion es este, para tomar una instantanea deben pasarle el parametro -t [nombredearchivo.png], con el nombre con el que quieren guardar la instantanea.
Les recomiendo que guarden este script en /usr/local/bin/ llamado photo, para asi en un futuro, cuando quieran utilizarlo simplemente hacen:

#: photo -t screenhost.png

Y listo, les cuento que tiene un delay de 7 segundos entre que se ejecuta el comando y se toma la instantanea de su desktop.

#!/bin/bash
#Toma instantanea del desktop
# Code by: Facundo M. de la Cruz
# fmdlc.unix [at] gmail dot com

COMMAND="$1"
case "$COMMAND" in
-t)
    echo "Se tomara una instantanea llamada $2"
    COUNT=7
    until [ $COUNT == "0" ]; do
             COUNT=$((COUNT-1))
             if [ $COUNT == "1" ]; then echo "Faltan 1 segundo"
             else
                   if [ $COUNT == "0" ]; then
                         scrot -e 'display $f' $2
                         echo "Listo, Nombre del archivo: $2"
                   else
                         echo "Faltan $COUNT segundos."
                   fi
             fi
             sleep 1
    done
    exit 0
;;
-h)
    echo "Sintaxis photo [-t/-h] [Nombre de archivo.png]"
    echo ""
    echo "-t Toma una instantanea."
    echo "-h Muestra esta ayuda."
    exit 0
;;
*)
    echo "Sintaxis photo [-t/-h] [Nombre de archivo.png]"
    echo ""
    echo "-t Toma una instantanea."
    echo "-h Muestra esta ayuda."
    exit 0
;;
esac
exit 0

Tags: , , ,
Jun
16.
Crear un informe del sistema rápidamente
No hay comentarios
Categoria: Uncategorized

En este post, voy a explicar como crear un util informe del sistema, para que se genere automaticamente (con cron), cada minuto y este mismo se coloque en nuestro servidor web (en el directorio /var/www/), para poder monitorear como se encuentra nuestra PC, siempre que estemos lejos de ella…

Lo primero que haremos es instalar mediante nuetros repositorios el programa sensorsd (que es el demonio) y lm-sensors, para ello en Debian hacemos lo siguiente:

#: apt-get install sensorsd lm-sensors

Una vez instalado esto, hay que configurarlo respondiendo a las diferentes preguntas que el instalador nos realize.
Luego lo que haremos es crear con nuestro editor de textos favoritos (el mio es Vim), un simple script como el siguiente:

#!/bin/bash
#——————
# SET VARIABLES
#——————
LOG1=”/var/log/messages”
LOG2=”/var/log/auth.log”
INFORME=”/var/www/informe.txt”

#—————-
# SUBRUTINAS
#—————-
function sensor {
    echo “INFORME GENERAL DEL SISTEMA”
    echo “Informe realizado: $(date)”
    echo “”
    echo “Uptime: $(uptime)”
    echo “”
    echo “Usuarios conectados:”
    echo “——————–”
    who –ips

    echo “”
    echo “Ultimos cinco accesos:”
    echo “———————-”

    echo “$(last -5 -a -i)”

    echo “Analisis de logs”
    echo “”
    echo “Ultimas entradas en $LOG1:”
    echo “——————————————”

    tail -n 5 $LOG1

    echo “”
    echo “Ultimas entradas en $LOG2:”
    echo “——————————————”

    tail -n 5 $LOG2
    echo “Sensores:”

    sensors

    if [ $? -ne 0 ]; then echo “sensors fallo”
    fi
}

# Llama a la función sensor
#############################
sensor > $INFORME

#Cambia permisos de /var/www
##############################
exec permisos &> /dev/null

#Notificación en tty
######################
echo “Se ha realizado un informe a las $(date +%H:%M%S) puede leerlo en: $INFORME”

exit 0

Bien, este script como vemos, lo que realiza es muy simple, en primer lugar asigna valor a las variables sobre los diferentes logs que debe leer (ustedes pueden cambiarlo por los que deseen), y tambien le asigna un valor a una variable que contendra el path hacia el informe (donde este debe ser creado y escrito). Paso siguiente ejecuta el comando date, para generar la fecha y la hora que se realizo el informe, luego ejecuta uptime, un who (para saber que usuarios estan conectados), verifica los ultimos cinco accesos con el comando last y los imprime en pantalla, luego imprime el primer el log contenido en la variable LOG1, y luego el log contenido en la variable LOG2 y ejecuta el programa sensors, el cual nos mostrara un informe detallado de nuestro hardware (con datos tales como temperaturas, voltajes, estado de coolers, etc…).
Termina enviando todo a un archivo que llamamos informe.txt en /var/www/, lo cual lo hemos definido en una variable llamada INFORME.

Por ultimo termina cambiando permisos del directorio contenido en la variable INFORME, para asi poder acceder remotamente, a travez de un script que hemos realizado y guardado en el directorio /usr/local/sbin, llamado permisos, el contenido de este script es el siguiente:

#!/bin/bash
#Cambiar permisos de webserver

#————————
# Set local variables
#————————

DIR=/var/www

#————————
#Subrutinas
#————————
echo “[*] Change permissions to the directory $DIR”
cd $DIR 2> /dev/null
if [ $? -ne 0 ]; then echo “Error”; PROBLEMA=1
fi

echo “[1] Entry to the directory $DIR”
chown -R www-data:www-data $DIR/* 2> /dev/null
if [ $? -ne 0 ]; then echo “Error”; PROBLEMA=1
fi

echo “[2] Making recursive chown to the directory $DIR”
if [ $? -ne 0 ]; then echo “Error”; PROBLEMA=1
fi

echo “[3] Making recursive chmod to the directory $DIR”
chmod -R 744 $DIR/* 2> /dev/null
if [ $? -ne 0 ]; then echo “Error”; PROBLEMA=1
fi
echo “[*] Done…”

if [[ "$PROBLEMA" -ne 1 ]]; then echo “No se encontraron problemas”
else
      echo “Se encontraron problemas al procesar”
fi
exit 0
#EOF

Obviamente los paths deben modificarlos a los que corresponden a su sistema, y los usuarios del webserver para los que ustedes quieran usar, en este ejemplo utilizamos www-data, pero pueden asignarle permisos a un grupo, por ejemplo haciendo uso adecuado de las ordenes chown, y chmod.
Guardamos este script en /usr/local/sbin con el nombre permisos.
Bien la parte mas dificil ya esta hecha ahora añadiremos la tarea a Cron, para que se ejecute cada minuto, de cada hora, de cada día y de cada mes, para ello con Vim, o el editor de textos que ustedes utilizen realizamos:

#: crontab -e

Y añadimos una línea como la siguiente:

0 * * * * root sh /usr/local/bin/informe > /dev/null 2>&1

Bien, ahora lo que tambien podemos hacer, es generar un alias, para que cada vez que tipiemos informe en nuestros sistemas, ademas de que se ejecute este, se presente en un visor de texto de forma adecuada. Yo para esta opcion utilizo el visor de Midnight Commander (mc -v), para ello abrimos nuestro archivo .bashrc o .bash_aliases (ambos en nuestro directorio home) y creamos un alias como el siguiente.

alias informe='/usr/local/bin/informe; mcedit -v /var/www/informe.txt

Si no tenemos Midnight Commander, podemos utilizar pager, more, less, etc.
Cabe aclarar que esta opción puede llegar a resultar insegura, ya que cualquiera podria leer la siguiente información y asi obtener usuarios y información de nuestro sistema.
En conveniente autentificar a los usuarios que tienen acceso a esta información como puede ser utilizando un password y una constraseña y asi permitirle el acceso a los usuarios permtidos a este archivo.

Tags: , , , ,
Jun
16.
Separar alias de .bashrc
No hay comentarios
Categoria: Uncategorized

Como ustedes saben, la definición de alias por defecto en Debian se encuentra en el archivo .bashrc en su directorio home. Para poder utilizar los alias generados en otro archivo (por ejemplo para organización); Deben hacer lo siguiente:

Editar con Vim o cualquier otro editor el archivo .bashrc de su home, descomentando el siguiente condicional, quedando como se muestra aquí:

if [ -f ~/.bash_aliases ]; then
   . ~/.bash_aliases
fi

Si analisamos un poquito las siguientes líneas vemos que el comiendo y el condicional esta comentado, por lo cual debemos proceder a eliminar los comentarios (#), para asi activar dicha opción, en palabras mas simples eliminamos el # comprendido desde la línea if hasta fi, de la condición.

Ahora con el mismo editor de textos creamos un archivo que contendra nuestros alias, llamado .bashrc_aliases, el cual su sintaxis debe ser masomenos asi:NOMBRE_ALIAS = 'COMANDO'Este seria un ejemplo:

alias dfh='df -h | ccze'

Debemos reejecutar Bash, para que sea cargado nuevamente .bashrc y se lea el archivo .bash_aliases.
Por lo que en una shell ejecutamos:

$: exec bash

Y listo, podemos comprobar haciendo un cat ~/.bash_aliases y deberiamos tener una salida masomenos como esta:

:~$: cat .bash_aliases
alias dfh='df -h | ccze'
alias dir='ls --color=auto --format=vertical'
alias informe='/usr/local/bin/informe'
alias l='ls -CF'
alias la='ls -A'
alias ll='ls -l'
alias ls='ls --color=auto'
alias startx='startx 2> /dev/null &'
alias vdir='ls --color=auto --format=long'
alias visor='mc -v'

Tags: , ,
Jun
10.
Actualizado: Escuchar Radios por Internet
No hay comentarios
Categoria: Uncategorized

Aca público una nueva versión del pequeño shell script escrito por Buanzo para escuchar radios argentinas por Internet desde sistemas operativos Unix-Like (Linux, BSD, etc.), la unica condición es estar corriendo bash y tener instalado mplayer en el sistema para asi poder ejecutarlo.

Para mas información vean el HOWTO que escribi hace un tiempo atras sobre el tema.

Recomiendo que guarden el archivo en el directorio /usr/local/bin con el nombre radio, asi directamente al querer escuchar una radio en la shell hacen:

$:radio

Y seleccionan la emisora que desean escuchar.
Ademas de radios se incluyen algunos canales de televisión en vivo como Canal26, TN 24, Discovery Channel y The National Geographics (estos ultimos dos en Inglés).

Leer más »

Tags: , , , , ,
Jun
10.
Reloj Cucu
1 Comentario
Categoria: Uncategorized

Les presento un pequeño script en Bash el cual intenta imitar a un reloj Cucu.
Deben agregarse las tareas a Cron, por ejemplo yo lo puse cada seis horas, entonces al llegar la hora indicada la unidad de CD/DVD se abrira la cantidad de veces que corresponde a la hora.
Ademas reproduce un pequeño archivo de sonido el cual es nada mas y nada menos que un cucu.
El codigo fue mejorado por mi, pero en realidad aparecio una primer idea en la revista Linux Users.

---- BEGIN ----
#!/bin/bash
#A funny Cucu Clock.

CUCU=$(/bin/date +%l)

while [ "$CUCU" -gt "0" ]; do
    eject /dev/hda > /dev/null 2>&1
    mplayer /usr/share/sounds/cucu.ogg &> /dev/null &
    eject -t /dev/hda > /dev/null 2>&1
    CUCU=$((CUCU-1))
done

exit 0
---- END ----

Tags: , ,
May
06.
Usando condicionales
No hay comentarios
Categoria: Uncategorized

Script que nos dice si un numero es divisible por dos.
Para utilizarlo debe darse permisos de ejecución al script (chmod +x script).
Utiliza condicionales: if, fi, then, else. Variables del entorno y el comando test.

if [ $# -ne 1 ]; then
       echo Uso: $0 numero
       exit 1
fi

if [ $(($1%2)) -eq 0 ]; then
       echo $1 es divisible entre 2
else
    echo $1 no es divisible entre 2
fi

Tags: ,

Creative Commons License
Esta obra es publicada bajo una licencia Creative Commons.