El rincón de Gu

Servidor Apache2 + SSL + subversion + websvn + DAV

gu — Fri, 19 Aug 2011 18:00:33 +0000

En esta entrada vamos a tratar la instalación y configuración básica de un servidor de repositorios y control de versiones con subversion bajo Debian squeeze.

Primero descargamos e instalamos los paquetes necesarios y sus dependencias, si no los tuviesemos ya, con sus configuraciones por defecto:

# apt-get install apache2 libapache2-mod-php5 openssl \
subversion libapache2-svn subversion-tools websvn

La configuración por defecto de websvn generará un archivo de configuración que interferirá con nuestros propósitos, por ello puedes borrarlo o comentar su contenido:

# rm /etc/apache2/conf.d/websvn

Acto seguido generamos el certíficado para la conexión segura, que lo haremos de la siguiente forma:

# mkdir /etc/apache2/ssl
# RANDFILE=/dev/random openssl req $@ -new -x509 -days 365 -nodes \
    -out /etc/apache2/sslcerts/websvn.pem \
    -keyout /etc/apache2/sslcerts/websvn.pem

# chmod 600 /etc/apache2/sslcerts/websvn.pem

En el momento de generar un certificado nos solicitará cierta información acerca de este, tales como el país, ciudad/provincia, empresa, área/departamento, etc.
El uso de un certificado generado de esta forma hará que el navegador muestre una alerta de seguridad. Si queremos evitar esto hay que pasar por caja y comprar un certificado a una Autoridad de Certificación.

Configuración de Apache2 + SSL + websvn

Pasamos a configurar el acceso seguro mediante SSL en Apache2, así como la ubicación de los repositorios.

El directorio donde alojaremos los repositorios, recordemos que debe estar accesible para websvn:

# mkdir /var/svn
# chown www-data:www-data /var/svn
# chmod 655 /var/svn

Creamos el archivo de configuración de Apache2:

# vi /etc/apache2/sites-available/svn

Contenido que agregaremos a este archivo:

NameVirtualHost *:443

        ServerAdmin default@exmaple.com
        SSLEngine On
        SSLCertificateFile /etc/apache2/sslcerts/websvn.pem

        DocumentRoot /var/www
        
                Options FollowSymLinks
                AllowOverride None
        

        
                Options Indexes FollowSymLinks MultiViews
                AllowOverride None
                Order allow,deny
                Allow from all
        

        Alias /websvn /usr/share/websvn
        
                DirectoryIndex index.php
                Options FollowSymLinks
                Order allow,deny
                Allow from all
                AuthType Basic
                AuthName "Subversion Repository"
                AuthUserFile /var/svn/.auth
                Require valid-user
       

       
                DAV svn
                SVNParentPath /var/svn/
                SVNListParentPath on
                AuthType Basic
                AuthName "Subversion Repository"
                AuthUserFile /var/svn/.auth
                Require valid-user

Ahora agregamos usuarios que tendrán permiso para acceder a nuesto repositorio:

# touch /var/svn/.auth
# chown www-data:www-data /var/svn/.auth
# htpasswd -m /var/svn/.auth nombre_del_usuario

Para agregar varios usuarios repetir la última línea tantas veces como sea necesario. Recuerda que con esta configuración todos los usuarios tendrán los mismos privilegios de acceso. Para afinar puedes consultar la documentación de mod_authz_svn

Observación de seguridad: el archivo con los datos de usuarios y contraseñas encriptadas únicamente sería accesible desde el exterior mediante el intérprete DAV. Si aun así queremos asegurarnos que no es accesible podemos agregar una directiva de seguridad en /etc/apache2/sites-available/svn, dentro del apartado VirtualHost:


Order allow,deny
Deny from all

Activamos el sitio en Apache:

# ln -s /etc/apache2/sites-available/svn \
/etc/apache2/sites-enabled/svn

O bien:

# a2ensite svn

Tras esto reiniciamos el servicio Apache:

# /etc/init.d/apache2 restart

Y ya podremos verlo!! Por supuesto debemos autenticarnos antes.
https://direccion_de_mi_sitio/websvn/ para acceder a websvn
https://direccion_de_mi_sitio/svn/ para acceder a subversion

Configurar y usar repositorios

Para agregar un nuevo repositorio:

# cd /var/svn
# mkdir mirepositorio
# svnadmin create mirepositorio
# chown www-data:www-data mirepositorio -R

En la interfaz de websvn aparece un repositorio de muestra llamado “repos 1″, para eliminar este hay que editar el archivo /etc/websvn/svn_deb_conf.inc y comentar o eliminar la línea donde se crea este.

...
#$config->addRepository("repos 1", "file:///var/svn");
...

Y ya por último, cómo agregar la información al repositorio. En mi caso he utilizado el cliente TortoiseSVN. Su uso es tan sencillo como abrir el “Repo-browser”, dar la dirección del repositorio (eg: https://misitio/svn/repositorio1), autenticarse y arrastrar los archivos a añadir o actualizar.

Fuentes consultadas:

In memorian

gu — Sat, 19 Mar 2011 00:59:22 +0000

Victor García Valero (1977-2011)

Si tuviera que decir cómo conocí a Victor no podría recordar el momento ni la situación, igual que recordar cómo aprendí a andar… Mayormente porque ambas cosas ocurrieron más o menos el mismo año. La verdad que podíamos pasar sin vernos durante 2 ó 3 años, y me arrepiento de no haberlo visitado en esta última etapa. No ya asiduamente, sino simplemente pasar a darle ánimos. “No te rindas Victor” le hubiera dicho. “El cáncer es uno y cobarde, tú puedes”… Pero se ve que no pudo.

Sinceramente a él le debo gran parte de mi frikismo informático. Por “su culpa” instalé OS/2 Warp sin haberlo tocado en mi vida (ni lo he vuelto a tocar desde entonces). Instalé Windows 95 el mismo dia que salió a la venta… Sí, por él me he metido en jaleos informáticos que me sobrepasaban y los superé. Y gracias a él aprendí muchas cosas, fue como una musa. No ya pasarnos juegos del Commodore 64, sino que cuando yo apenas me saltaba las claves del PC de casa (un Inves con procesador NEC V20 a 10MHz) para continuar mi ciudad del SimCity (en blanco y negro) o jugar al Dyna Blaster, él ya andaba liado con BBS con un MODEM 28kbps. Cuando yo ya jugaba al Alone in the Dark en un 486, él estaba conectando a Internet directamente a EEUU (con un MODEM de 96Kbps), porque en España era imposible. El primer ordenador con ACPI que vi fue el suyo. A su nivel fue pionero en muchas cosas, siempre relacionado con las telecomunicaciones. Si existía algún aparato raro o lo tenía o lo iba a conseguir o se lo habían prestado.

Victor, ya no hace falta que te mande un abrazo, porque siempre estarás entre nosotros. Ahora no estás más lejos, sino que te tenemos al lado.

Repercusión mediática:

Formularios y juego de caracteres

gu — Tue, 19 Oct 2010 09:02:52 +0000

¿A quién que haya programado un sitio web no le ha ocurrido que en el texto aparecieran caracteres extraños en lugar de vocales con tilde y eñes? Pues eso se debe al uso de distintos juegos de caracteres entre las distintas partes que componen nuestro sitio. Lo más normal es entre el Sistema Gestor de Bases de Datos y los archivos de script, pero hay más casos, como el envío asíncrono de datos mediante JavaScript.

La recomendación es utilizar UTF8 en todos los casos, esto nos quitaría gran cantidad de problemas. Sin embargo debemos tener especial cuidado en la codificación de los archivos de copia de seguridad, ya que al recuperar los datos pueden hacer un estropicio importante; e incluso la que utilizan los programas de gestión adicionales que utilicemos (PHPMyAdmin, MySQL Query Browser, etc).

Igual de importante es la codificación utilizada en los archivos que componen nuestro sitio (.htm, .php, .js, .css…), ya que un archivo codificado en ANSI, Unicode o UTF8 y mostrado en una codificación diferente nos mostrará caracteres raros igualmente. Así pues si nuestro sitio está completamente realizado con un juego de caracteres ISO, utilizaremos ficheros ANSI; y UTF8 con su par. Mi experiencia con Unicode ha sido de auténticos dolores de cabeza, de modo que no recomiendo su uso, al menos para trabajar con páginas en español.
El software de edición debe tener la posibilidad de trabajar con distintas codificaciones, hasta si eres un masoquista y utilizas el bloc de notas de MS-Windows tienes esta posibilidad en “Guardar como…”.

Ahora bien ¿qué ocurre al transferir datos de un script a otro? Pues lo mismo, ambos deberían tener la misma codificación. No obstante en PHP disponemos de las funciones utf8_encode y utf8_decode, siempre que el cambio sea entre UTF-8 e ISO-8859-1. Estas funciones nos serán muy útiles a la hora de recodificar los datos recibidos para alojarlos en la base de datos con el juego de caracteres adecuado. También nos serán útiles cuando los datos los recibimos de otro sitio web sobre el que no tengamos control.

Existe una problemática adicional cuando trabajamos con ISO-8859-1 y enviamos los datos mediante AJAX, ya que siempre se envían en UTF.

Como recomendación adicional, especificar el juego de caracteres utilizado tanto en las cabeceras de HTML como en la del documento mediante PHP, ya que el servidor web por defecto enviará las establecidas. Por ejemplo MS-IIS por defecto informa que se usa el juego de caracteres ISO-8859-1.





ejemplo


...

Por último, para una reconversión de los datos recibidos, podemos utilizar un sencillo bucle:

foreach ($_POST as $key => $val)
    $$key = utf8_decode($val);

Si además esos datos los vamos a incluir en una consulta MySQL:

foreach ($_POST as $key => $val)
    $$key = mysql_real_esacape_string(utf8_decode($val));

Espero que sea de utilidad.

BackUp de MySQL con PHP y compresión ZIP

gu — Wed, 13 Oct 2010 10:32:15 +0000

Rescato un tema que tenía publicado en Foros del Web.

La base de datos del trabajo ha superado 1GB de tamaño, por lo que seguir haciendo dumps a lo bruto no es viable.

Es por ello que me he currado un script y lo he añadido al “cron diario” del servidor.

La forma de funcionar es ver las distintas bases de datos de usuario y volcarlas mediante el comando mysqldump. Posteriormente se comprime en ZIP y se eliminan los archivos temporales utilizados. Luego eliminaría las copias antiguas (en este caso, anteriores a 3 dias).

#############################################
#
# Tarea de copia seguridad de todas las bases de datos en MySQL
#
# CopyLeft, puedes hacer con este script lo que te de la gana
#
#############################################
set_time_limit(0);
header("Content-type: text/plain; charset=UTF-8");
echo date("Y-m-d H:i", time()) . " Creando copia de seguridad MySQL...\r\n";

// Datos de acceso a MySQL
$myhost = "localhost";
$myuser = 'root';
$mypass = 'miclave';
$DB = mysql_connect($myhost, $myuser, $mypass) or die(date("Y-m-d H:i", time()) . " ERROR!! No se pudo conectar a MySQL.\r\n");

// Otros parámetros
$OUTDIR = "D:\\backup\\"; // Cambiar segun necesidades y tipo servidor
$now = date("YmdHi", time());
$outfile = "MySQL_$now.zip";
$periodo = time() - 259200; // Los archivos anteriores a este periodo (3 dias = 259200 segundos) serán borrados

// Crear nuevo archivo ZIP
# Más información sobre la clase PHP
# http://es.php.net/manual/en/class.ziparchive.php
echo date("Y-m-d H:i", time()) . " Creando '$OUTDIR$outfile.zip' ... ";
$zip = new ZipArchive;
if (!$zip->open("$OUTDIR$outfile", ZIPARCHIVE::CREATE)) die("ERROR!!\r\n");
echo "OK.\r\n";

// Tomar un listado de bases de datos
$q = mysql_query("SHOW DATABASES");

// Volcar todas las bases
while ($database = mysql_fetch_row($q))
    if ($database[0] != "information_schema" && $database[0] != "mysql")
        {
        // Nombrar archivo
        $filename = "{$database[0]}.sql";
        $tempfile = date("YmdHis", time()) . ".~swap";

        echo date("Y-m-d H:i", time()) . " Volcando '$filename' ... ";

        // Volcar datos
        system("mysqldump -h $myhost -u $myuser -p$mypass --opt {$database[0]} > $OUTDIR$tempfile");

        echo "OK.\r\n"
        . date("Y-m-d H:i", time()) . " Agregando '$filename' a '$outfile' ... ";

        //  Agregar archivo al ZIP
        $zip->addFile($OUTDIR.$tempfile, $filename);

        // Recordar los temporales utilizados
        $DUMPFILES[] = $OUTDIR.$tempfile;

        echo "OK.\r\n";
        }

// Desconectar de la base de datos
mysql_close($DB);

// Cerrar archivo ZIP
$zip->close();

// Eliminar temporales. Importante hacerlo DESPUÉS de cerrar el ZIP
foreach($DUMPFILES as $file)
    unlink($file);

// Elminar archivos antiguos
echo date("Y-m-d H:i", time()) . " Eliminando copias antiguas...\r\n";
$D = opendir($OUTDIR);
while ($F = readdir($D))
    if ($F != "." && $F != "..")
        if (filectime($OUTDIR.$F) < $periodo)
            if (!unlink($OUTDIR.$F))
                echo date("Y-m-d H:i", time()) . " No se pudo eliminar el archivo $F.\r\n";
closedir($D);

echo date("Y-m-d H:i", time()) . " Tarea finalizada.\r\n";

Gracias a la compresión en ZIP ahora la copia diaria ocupa ~77MB en vez de ~1GB.

Espero que os sirva a muchos/as.

Gestión de la navegación de una web (básico)

gu — Thu, 07 Oct 2010 15:58:09 +0000

A la hora de maquetar un sitio web debemos tener en cuenta la estructura que va a tener. Aquí os propongo un método de navegación por parámetros GET, que si además lo combinais con mod_rewrite o similar, quedará bastante mejor desde el punto de vista SEO al tener una URI más amigable. Pero esa es otra historia que lo mismo toco en el futuro.

La cosa es que en nuestro sitio web tendremos el contenido almacenado en archivos o en una base de datos y accederemos a una u otra parte por unos enlaces internos. Para el artículo y para que sea más comprensible la explicación voy a prescindir del uso de la base de datos. Es decir, voy a poner un ejemplo de un sitio hecho a jierro, si bien en la práctica no es lo más adecuado.

Pues considerando que nuestro sitio va a tener distintos apartados o secciones y sus correspondientes subsecciones, utilizaremos para navegar dos variables “sec” y “sub”.

Los enlaces pues quedarán algo parecido a ./?sec=catalogo&sub=productos. Con mod_rewrite quedaría un enlace tipo ./catalogo/productos/.

Para obtener estos valores, podemos hacer algo como esto:

// inicializar valores
$sec = $sub = "";

// Tomar valores si estuviesen disponibles.
if (isset($_GET['sec'])) $sec = $_GET['sec'];
if (isset($_GET['sub'])) $sub = $_GET['sub'];

¿Como manejamos internamente estas variables?
Pues lo más cómodo es con un “switch”, de forma que validamos todas las opciones y si no es correcta podemos mostrar una página de error personalizada.
En función de cada valor cargaremos una página u otra. Es más, podemos (de hecho es recomendable) cambiar el título de la página, las metaetiquetas y otros detalles en función de cada sección.
Así pués hagamos una plantilla de la página.



$TITULO - mi sitio




  
    Inicio
    sección 1
    sección 2
      
        sección 2.1
        sección 2.2
      
    
    sección 3

En el ejemplo he introducido 2 variables
$TITULO: el título dinámico de la página
$FILE: el archivo a incluir con el contenido

Pues ahora vamos a gestionar la navegación:

switch ($sec)
  {
  case "": // Inicio
    break;
  case "seccion1":
    $TITULO = "asdf 1";
    $FILE = "s1.htm";
    break;
  case "seccion2":
    switch ($sub)
      {
      case "apartado1":
        $TITULO = "asdf 2.1";
        $FILE = "s2a1.htm";
        break;
      case "apartado2":
        $TITULO = "asdf 2.2";
        $FILE = "s2a2.htm";
        break;
      }
    break;
  case "seccion3":
    $TITULO = "asdf 3";
    $FILE = "s3.htm";
    break;
  default: // La sección no se ha encontrado, mostramos la página de error
    header("HTTP/1.0 404 Not Found");
    $TITULO = "Error 404";
    $FILE = "error.htm";
  }

// Comprobar que existe el fichero a incluir
if (!is_file($FILE))
  { // Es un error gordo, mostramos un mensaje y paramos la ejecución
  header("HTTP/1.0 404 Not Found");
  die("Error: archivo no encontrado");
  }

Este código, como es lógico, debe ir ANTES de la plantilla. Incluso podemos tener la plantilla por un lado, el control de navegación por otro y en index.php los includes necesarios.

¿Qué me dejo en el tintero?
Para hacer esto mismo pero usando una base de datos hay un paso sencillo ya que en vez de tener varios switch anidados monstruosamente largos tendríamos una consulta de búsqueda a nuestra tabla de artículos, de donde obtendríamos tantos datos como necesitasemos (títulos, meta-etiquetas, privilegios de acceso, …); al igual que el menú, podría estar almacenado en otra tabla. Por supuesto tenemos que prevenirnos ante ataques de SQL-Injection. NUNCA pongas el valor de una variable GET o POST directamente en una consulta SQL.

Variante: Podemos simplificar mucho el control si el valor de “sec” fuese el nombre del fichero a incluir (sin la extensión). Por supuesto esto trae algunos inconvenientes de seguridad, así que no está de más comprobar que el nombre no contiene más que caracteres alfanuméricos y que el fichero se trata de un artículo.

Paginación de listados

gu — Thu, 30 Sep 2010 09:56:26 +0000

En muchas ocasiones, ya sea por estética o por reducir tiempos de carga, es preciso mostrar un listado en varias páginas. Esto lo haremos mediante el uso de LIMIT en nuestra consulta. En MySQL, LIMIT puede tener 1 ó 2 argumentos numéricos. Para nuestras necesidades usaremos los 2: el primero determina el nº de registro inicial y el 2º la cantidad de registros a mostrar.

Para el ejemplo imaginemos que tenemos una tabla productos y que el listado lo realizaremos por familia o por un criterio de búsqueda del usuario y para no extendernos mucho será simplemente una búsqueda por nombre o descripción del artículo.
A la hora de generar los enlaces a las distintas páginas debemos mantener los criterios de la búsqueda, para ello usaremos 2 campos GET: familia para búsqueda por familia y desc para búsqueda por descripción; de forma que los enlaces quedarán algo parecido a ./catalog.php?family=4&desc=pedal+freno.

Pues ¡pasemos a la acción! Definamos los pasos a realizar:

validar los criterios de búsqueda
construir la consulta
calcular el total de artículos
generar el listado de páginas
mostrar la página de resultados

Los 2 primeros pasos los vamos a mezclar.

$familia = 0;
$where = $busqueda = "";
if (isset($_GET['familia']))
    { // Se trata de un valor numérico para búsqueda de un identificador
    $familia = intval($_GET['familia']);
    if ($familia) // Esta 2ª comprobación es para que no busque por la familia 0, considerando que se trata de un campo clave autonumérico.
        $where .= " AND familia_id=$familia";
    }

if (isset($_GET['desc']))
    { // Es un valor introducido por el visitante, NUNCA te fies de lo que envía el cliente
    $busqueda = mysql_real_escape_string($_GET['desc'])
    $where .= " AND (nombre LIKE '%$busqueda%' OR descripcion LIKE '%$busqueda%')";
    }

$pag = 1;
if (isset($_GET['pag'])) // página actual
    $pag = intval($_GET['pag']);

En la búsqueda por descripción podríamos tener un campo adicional tipo checkbox para indicar si queremos buscar en la descripción del artículo además de en el nombre de este.

Definidos los criterios, calculamos la cantidad total de resultados, tal que así:

$total = mysql_fetch_row(mysql_query("SELECT COUNT(*) FROM articulos WHERE activo=1 $where"));
$total = $total[0];

Llegado a este punto si no hay resultados ($total == 0 o símplemente !$total) podemos parar y ahorramos tiempo ejecutando el resto.

Nótese que podría haber hecho una consulta de un campo (o de todos) y luego utilizar la función mysql_num_rows(). Sin embargo usar COUNT en la consulta es mucho más rápido, además de darle menos trabajo a nuestro servidor.

Pues ahora que tenemos lo básico, generamos los enlaces para la navegación por páginas.

// Definimos cuantos resultados por página (rpp) queremos. Nuevamente esto podría ser una opción del formulario de búsqueda.
define("_RPP", 10);
function paginas($total=0, $familia=0, $criterio="", $actual=1)
	{
	$OUT = "";
	// Calculamos el total de páginas
	$paginas = ceil($total/_RPP);
	for ($p=1, $p<$paginas+1, $p+=1)
		{
		if ($p != $actual)
			$OUT .= "\t$p\n";
		else
			$OUT .= "\t$p\n";
		}

	 // Definos los enlaces para "pagina anterior" y "página siguiente"
	 $anterior = "\t«\n";
	 $siguiente = "\t»\n";

	 if ($actual != 1)
		 $anterior = "\t«\n";
	 if ($actual != $paginas)
		 $siguiente = "\t»\n";

	// Es cuestión de gustos, a mi me gusta usar listas para este tipo de cosas y aplicarle un estilo
	$OUT = "\n"
	. $anterior
	. $OUT
	. $siguiente
	. "\n"

	return $OUT;
	}

El estilo de la lista de páginas podría ser algo así:

ul.paginas { clear:both; }
ul.paginas > li { float:left; padding:2px 4px 2px; }
ul.paginas > li > a { font-weight:bold; text-decoration:none; }

Pues ahora la traca final: hacer la consulta y mostrar los artículos.

// Calcular registro inicial (nº de página actual multiplicado por los registros por página)
$registro = ($pag - 1) * _RPP;

// Construir consulta SQL
$sql = "SELECT a.*, f.nombre"
. " FROM articulos a"
. " INNER JOIN familias f ON f.id=a.familia_id"
. " WHERE a.activo=1 ". $where
. " ORDER BY a.nombre" // Esto podría ser otro criterio para la búsqueda
. " LIMIT $registro, ". _RPP;

// Realizar la consulta
$query = mysql_query($sql);
if (mysql_num_rows($query)
    {
    $BODY = "";
    while ($a = mysql_fetch_array($query))
        {
        $BODY = "\n"
        . "Artículo: {$a['nombre']}\n"
        . "Descripción: {$a['descripcion']}\n"
        . "\n";
        }

    // Presentarlo todo
    echo paginas($total, $familia, $busqueda, $pag)
    . $BODY
    . paginas($total, $familia, $busqueda, $pag);
    }

Espero que el artículo sea interesante y útil! No dudes en criticarme en los comentarios
Me tomé la libertad de darle formato a la salida, así como agregar tabulaciones y saltos de línea. Es una costumbre que tengo que facilita la revisión del código HTML generado.