Búsqueda avanzada de archivos con find, locate y grep

8 Diciembre, 2008 | Comentarios (1)

Todos los que trabajamos asiduamente con un terminal no podemos evitar en algún momento lidiar con la tarea de búsqueda de archivos por nombre o incluso por contenido, incluso podemos querer ejecutar comandos con los resultados obtenidos.

Utilizaremos estos dos comandos: find, locate, grep.

Find

Busca en un directorio seleccionado segun unos modificadores proporcionados entre los que podemos destacar

  • -iregex para buscar con una expresión regular sin tener en cuenta las mayusculas/minúsculas
  • -regex para buscar con unha expresión regular teniendo en cuenta las mayusculas/minúsculas
  • -name para buscar segun un nombre dado se puede proporcionar una expresión regular
  • -empty para buscar ficheros vacíos
  • -user para buscar arquivos que pertenecen a un usuario determinado
  • -group para buscar arquivos que pertenecen a un grupo de sistema determinado
  • -atime -mtime etc. utiliza el tiempo de modificación, acceso, creación… de los archivos
  • -executable para buscar archivos con el flag de ejecutable
  • -type [letra] para buscar archivos [letra]=f , directorio [letra]=d, enlaces simbólicos [letra]=l, ficheros socket [letra]=s

además también proporciona modificadores de acción, esto es, modificadores que le dicen al comando que hacer con los resultados

  • -print imprime el nombre de archivo completo en la salida estándar
  • -exec {} ejecuta el comando seleccionado en {}
  • -delete borra el archivo

Ejemplos prácticos:
find . -exec grep "www.athabasca" '{}' \; -print
#busca la cadena "www.athabasca" dentro del contenido de los archivos del directorio actual y los imprime

find . -name "rc.conf" -exec chmod o+r '{}' \;
#le cambia el modo a o+r a los archivos con nombre rc.conf en el directorio actual

find . -perm -g+w,u+w ! -perm -o+w
#busca los archivos que son escribibles por el propietario o su grupo, pero no el resto

Locate

Locate supone un salto en el rendimiento respecto al comando find siempre y cuando busquemos los archivos por su nombre. La razón del rendimiento de locate es que utiliza un índice de nombres de archivos normalmente ubicado en /var/lib/mlocate/mlocate.db. Normalmente tódolos los sistemas UNIX tienen una tarea de cron que actualiza dicha base de datos, aún así si queremos actualizarla manualmente podemos ejecutar el comando updatedb.

Podemos destacar varios modificadores de dicho comando:

  • –limit limita el número de resultados
  • –count imprime el número de resultados en vez de los resultados mismos.
  • –regex busca en la base de datos según una expresión regular

En la siguiente imagen podemos ver la diferencia de rendimiento entre find y locate, encontrado aquí:
Find locate comparison performance

Grep

Muy utilizado comando sobre todo utilizando tuberías ( | ), se utilza principalmente para buscar ficheros según el contenido de los mismos. La mejor forma de observar su comportamiento es mediante ejemplos:
grep 'string' *.txt #busca la cadena "string" en todos los archivos .txt
grep 'main(' *.c #busca la cadena "main(" enn todos los archivos .c
grep -i 'ultra' *.conf #busca la cadena ultra (sin tener en cuenta mayusculas/minúsculas) en los ficheros .conf
grep -iR 'ultra' *.conf
#busca la cadena ultra (sin tener en cuenta mayusculas/minúsculas) en los ficheros .conf en el directorio actual y subdirectorios del mismo

Y ahora unos truquillos:

$ grep --color=auto -iR 'getChar();' *.c #resalta los resultados para ver mejor el texto

$ grep --color=auto -iRnH 'getChar();' *.c  #muestra el nombre de archivo y número de línea donde se encontró la cadena

Y ahora combinando find y grep:

$ find . -name "*.c" -print | xargs grep "main(" #busca en tódos los ficheros .c la cadena "main)"

Como acabamos de ver tenemos diversas posibilidadades, que luego de estudiarnos un poco la sintaxis de los comandos nos harán abandonar las lentas y a veces podo intuitivas GUIs.

Archivado en... Truquitos Vida virtual

Configuración de PHP 5 en Nginx (Nginx III)

20 Noviembre, 2008 | Comentarios (0)

Continuamos con el periplo de configurar Nginx siguiente con las dos anteriores entradas.
Ahora lo que trataremos es de ejecutar nuestras apps o scripts escritos en PHP 5. Let’s go.

Instalación de PHP

La instalación de PHP no tiene mucha ciencia en GNU/Linux:
$ sudo apt-get install php5-cli php5-cgi php5-mysql
$ php -v
PHP 5.2.0-8+etch9 (cli) (built: Dec 29 2007 14:49:25)
Copyright (c) 1997-2006 The PHP Group
Zend Engine v2.2.0, Copyright (c) 1998-2006 Zend Technologies

Instalación de FastCGI

Ya que nginx no cuenta con módulo integrado de php, precisamente porque no encuadra en su arquitectura, la ejecución del código PHP lo vamos a hacer a través de FastCGI. Para eso  utilizaremos la implementación que viene con lighttpd. Básicamente lo que haremos será compilar lighttpd, para luego copiar simplemente el spawn-fcgi
wget http://www.lighttpd.net/download/lighttpd-1.4.18.tar.gz
gunzip lighttpd-1.4.18.tar.gz
tar xvf lighttpd-1.4.18.tar
cd lighttpd-1.4.18/
./configure
make
sudo cp src/spawn-fcgi /usr/bin/spawn-fcgi

Ahora tendremos que crear un ejecutable:

  1. <code>#!/bin/sh
  2. /usr/bin/spawn-fcgi -a 127.0.0.1 -p 9000 -u www-data -f /usr/bin/php5-cgi
  3. </code>

Y su script de control

  1. #!/bin/bash
  2. PHP_SCRIPT=/usr/bin/php-fastcgi
  3. RETVAL=0
  4. case "$1" in
  5.     start)
  6.       $PHP_SCRIPT
  7.       RETVAL=$?
  8.   ;;
  9.     stop)
  10.       killall -9 php5-cgi
  11.       RETVAL=$?
  12.   ;;
  13.     restart)
  14.       killall -9 php5-cgi
  15.       $PHP_SCRIPT
  16.       RETVAL=$?
  17.   ;;
  18.     *)
  19.       echo "Usage: php-fastcgi {start|stop|restart}"
  20.       exit 1
  21.   ;;
  22. esac
  23. exit $RETVAL

al que arreglamos sus permisos y lo hacemos ejecutar al inicio del sistema:
sudo chmod 755 /etc/init.d/php-fastcgi
sudo chmod 755 /usr/bin/php-fastcgi
sudo /usr/sbin/update-rc.d -f php-fastcgi defaults

y escribir una serie de parámetros que necesita el spawn para hacer que todo funcione correcto en la comunicación con nginx insertando el siguiente bloque de configuración en

  1. /etc/nginx/fastcgi.conf
  1. fastcgi_param  QUERY_STRING       $query_string;
  2. fastcgi_param  REQUEST_METHOD     $request_method;
  3. fastcgi_param  CONTENT_TYPE       $content_type;
  4. fastcgi_param  CONTENT_LENGTH     $content_length;
  5.  
  6. fastcgi_param  SCRIPT_NAME        $fastcgi_script_name;
  7. fastcgi_param  REQUEST_URI        $request_uri;
  8. fastcgi_param  DOCUMENT_URI       $document_uri;
  9. fastcgi_param  DOCUMENT_ROOT      $document_root;
  10. fastcgi_param  SERVER_PROTOCOL    $server_protocol;
  11.  
  12. fastcgi_param  GATEWAY_INTERFACE  CGI/1.1;
  13. fastcgi_param  SERVER_SOFTWARE    nginx;
  14.  
  15. fastcgi_param  REMOTE_ADDR        $remote_addr;
  16. fastcgi_param  REMOTE_PORT        $remote_port;
  17. fastcgi_param  SERVER_ADDR        $server_addr;
  18. fastcgi_param  SERVER_PORT        $server_port;
  19. fastcgi_param  SERVER_NAME        $server_name;
  20.  
  21. # PHP only, required if PHP was built with –enable-force-cgi-redirect
  22. fastcgi_param  REDIRECT_STATUS    200;

bastaría añadir la configuración a nuestro virtual host para tener soporte por fin y finalmente de php

  1. location ~ \.php$ {
  2.   fastcgi_pass   127.0.0.1:9000;
  3.   fastcgi_index  index.php;
  4.   fastcgi_param  SCRIPT_FILENAME  /var/www/blog.codefront.net$fastcgi_script_name;
  5.   include        /etc/nginx/fastcgi.conf;
  6. }

Espero os haya sido productivo.

Archivado en... General

Acceso rápido a la documentación de tus gemas de Ruby

7 Agosto, 2008 | Comentarios (0)

Durante una de mis sesiones de lectura de blogs me encontré que en el de Sergio Gil, programador en The Cocktail, había escrito como tener acceso directo a las gemas mediante un script de Bash que además autocompleta.

La verdad es que es muy cómodo, y no tienes que recurrir a el conocido `gem server`, el cual tiene que levantar un servidor webrick para acceder a toda la documentación. Con este hack no se consumen recursos adicionales y exprimir todavía más nuestro equipo para otras tareas.

El único problema que tiene el post de Sergio es que es dedicado a bash, y hace algún tiempo que proceso amor por zsh, por lo que he hecho la modificación para que rule en la misma.

Simplemente copiad el siguiente código en vuestro ~/.zshrc y ya teneis el comnado gemdoc con autocompletado.

  1. export GEMDIR=`gem env gemdir`
  2. gemdoc() {
  3. open $GEMDIR/doc/`ls -FG $GEMDIR/doc | grep $1 | sort | tail -1`/rdoc/index.html
  4. }
  5. _gemdocomplete() {
  6. compctl -/ -W $GEMDIR/doc gemdoc
  7. return 0
  8. }
  9. _gemdocomplete

Por lo tanto solo habría que escribir en terminal
gemdoc
y se autocompletan los nombres de las gemas con sus respectivas versiones, si no proporcionas la version se cogerá la última versión.

Configuración de MySQL para rendimiento

3 Agosto, 2008 | Comentarios (0)

En el desarrollo de aplicaciones contra bases de datos, la mayoría de las veces, necesitas unos valores de referencia para saber si las consultas o instrucciones que está procesando tu aplicación se están comportando como debiere. También si te toca administrar un servidor de bd y monitorearlo este post te será de gran ayuda.

En este sentido escribiré algunos de los parámetros que podemos monitorear para el caso de bases de datos MySQL.

Básicamente MySQL nos proporciona una serie de instrucciones SQL que nos devuelve información de estado y rendimiento del servidor, para que luego las evaluemos y decidamos que acción pertinente se lleva a cabo.

La instrucción básica que se usa en MySQL es

  1. SHOW STATUS;

la cual nos devuelve una cantidad importante de estados de variables. Aquí explico las más importantes.

Threads_connected

Esta variable indica el número total de clientes que tienen una conexión abierta actualmente con el servidor.
Proporciona información en tiempo real de cuantos clientes están conectados con el servidor. Esto puede ser de ayuda para analizar el tráfico o decidir cuando es el mejor instante para reiniciar un servidor.

Created_tmp_disk_tables

Esta variable indica el número de tablas temporales que han sido creadas en disco frente a hacerlo en memoria.
El acceso a tablas en disco normalmente es más lento que acceder a ellas en memoria. Por tanto las consultas que usan la sintaxis CREATE TEMPORARY TABLE son más lentas si el valor de la esta variable es superior.

Leer más →






: