Facebook es uno de los sitios web más concurridos del planeta, de hecho, según el ranking de Alexa es el segundo dominio con más tráfico de internet. Esta red social se encuentra desarrollada en PHP, lo que demuestra la gran escalabilidad que puede llegar a tener esta tecnología.

Los ingenieros de Facebook, se han tenido que enfrentar a muchos problemas a la hora de mantener en pie su portal, y uno de ellos es la cantidad de CPU usada por PHP, que al tratarse de un lenguaje dinámico requiere un mayor uso de la CPU para ejecutar el código. Para optimizar este proceso, los ingenieros de Facebook han creado el proyecto “HipHop for PHP”.

HipHop for PHP analiza el código fuente en PHP y lo convierte en un código C++ que se compila con g++. Este código C++ se ejecuta como extensión de PHP, es decir, lo que se ejecuta es una dll, un binario ejecutable, y no se tiene que interpretar el código cada vez que se hace una petición.

Con este sistema han logrado reducciones de uso de CPU de hasta el 50%, que es un resultado más que interesante.

Pese a lo interesante que parece, el sistema acaba de ser anunciado y no es perfecto, por lo que si nuestro código hace uso de funciones PHP propias de lenguajes dinámicos, como eval(), o create_function(), HipHop no será capaz de transformar el código fuente, aunque se está trabajando en soportar estas funciones.

¿Te imaginas el core de Joomla optimizado con HipHop? ¿Te imaginas poder instalar una extensión de PHP que ejecute toda la lógica de CMS’s como Joomla o WordPress reduciendo en un 50% el uso de CPU? En un futuro es posible, quien sabe.

En Ustream puedes ver el video de la presentación en inglés.

Timthumb es un script PHP, desarrollado por Darren Hoyt, que resulta muy útil para redimensionar imágenes usando PHP. Se utiliza bastante en templates para WordPress, para crear los thumbnails de los posts. Además permite hacer crop de las imágenes para que no pierdan las proporciones al ser redimensionadas. Necesita que la librería GD esté cargada, cosa que casi todos los hostings tienen.

Para empezar a usar el script solo tienes que bajartelo desde el SVN de Google Code. Una vez descargado, muévelo a tu servidor web. La primera vez que lo uses, el script creará un subdirectorio con el nombre “cache”. En este subdirectorio se almacenarán los thumbnails realizados para no tener que redimensionar las imágenes cada vez que se realiza una petición. El subdirectorio “cache” tiene que tener permisos de escritura y ejecución para que todo funcione bien (por supuesto, de lectura también). Una vez todo esté en sus sitio puedes empezar a usar el script de esta manera tan sencilla:

<img src="/scripts/timthumb.php?src=/images/imagen_grande.jpg&h=150&w=150&zc=1" alt="thumb" >

Las opciones que tiene el script son las siguientes:

• w: anchura del thumbnail
• h: altura del thumbnail
• zc: zoom crop (0 o 1)
• q: quality (por defecto es 75, y lo máximo es 100)

Ejemplos de Timthumb

He realizado algunos ejemplos usando una imagen de un balón de futbol. El tamaño original de la imagen es de 1280×1024. Vamos a ver el efecto del script sobre la imagen:
Redimensión a 150×150 sin zoom crop

<img src="/scripts/timthumb.php?src=/images/balon_grande.jpg&h=150&w=150" alt="thumb" >

Redimensión a 150×150 con zoom crop

<img src="/scripts/timthumb.php?src=/images/balon_grande.jpg&h=150&w=150&zc=1" alt="thumb" >

Como se puede observar, el zoom crop hace su faena y evita que la imagen se distorsione, aunque sea a costa de perder un trozo de imagen en el lateral. Si quieres que la imagen ocupe menos espacio puedes jugar con el parametro “q”, que por defecto se establece a 75, pero lo puedes reducir para bajar la calidad del thumbnail y que ocupe menos espacio.
Redimensionar solo la altura

<img src="/scripts/timthumb.php?src=/images/balon_grande.jpg&h=150" alt="thumb" >

Indicando solo la altura, se redimensiona la imagen manteniendo las proporciones.

Posición del crop

El crop, por defecto se hace en la parte central de la imagen, pero en imágenes grandes puede ser que al hacer crop se elimine la parte de la imagen menos apropiada. Para evitar esto Studio-XL ha desarrollado una modificación del script. Se puede descargar desde su sitio. Su script funciona exactamente igual, pero añade la opción de especificar el parámetro “cropfrom”. Cropfrom puede tener los siguientes valores:

1. middle
2. middleleft
3. middleright
4. topleft
5. topright
6. topcenter
7. bottomleft
8. bottomright
9. bottomcenter

El resultado de aplicar estos parámetros es el siguiente:

Cropfrom topleft

<img src="/scripts/timthumb.php?src=/images/balon_grande.jpg&h=150&w=150&zc=1&cropfrom=topleft" alt="thumb" >

Cropfrom topright

<img src="/scripts/timthumb.php?src=/images/balon_grande.jpg&h=150&w=150&zc=1&cropfrom=topright" alt="thumb" >

Un script muy fácil de usar que sin duda nos puede ayudar a crear plantillas más creativas.

La programación web es un mundo complejo e inseguro. La seguridad de nuestra aplicación depende de muchos factores que debemos tener en cuenta, desde la seguridad del servidor donde se aloja, hasta las técnicas de programación empleadas en esta.

Una de las vulnerabilidades que más se ha explotado útimamente han sido las basadas en ataques XSS (Cross Site Scripting), que consiste en inyectar código malicioso en un sitio web para que se ejecute automáticamente al abrirlo en el navegador.

Imagina por un momento que eres un Webmaster de una comunidad de usuarios y utilizas el CMS Joomla para administrarla. Imagina que usas un componente de terceros para administrar los roles de usuarios, etc.. algo muy común. Un buen día llegas a casa y abres una sesión como administrador de tu sitio, y te quedas logueado con la pestaña abierta. Ahora abres otra pestaña, y en esta pestaña hay un código Javascript que hace algo como lo siguiente:

window.location.href= "http://tuSitioJoomla/administrator/index2.php?option=com_users&task=deleteall..."

Al estar logueado como administrador, si el componente no está debidamente protegido es posible que llegue a borrar todos los datos de nuestros usuarios, y nuestra amada comunidad se irá al garete en menos que canta un gallo. Si encima, estó lo combinamos con una política de copias de seguridad insuficiente o inexistente, nos encontraremos ante una situación bastante dificil de resolver y que seguro que nadie le gustaría vivir.

Esta técnica de construir consultas maliciosas aprovechandose de la sesión de un administrador es una rama del XSS denominada como CSRF(Cross Site Request Forgery).

Para evitar estos problemas de seguridad, el API de Joomla proporciona unos métodos interesantes cuya finalidad es comprobar que la petición se ha realizado desde un sitio seguro, y no la está relizando cualquiera. Estos métodos generan un Token, (en español testigo) que es único para cada sesión que se genera en el servidor. Este token es un conjunto de carácteres generados en base a tu dirección IP, hora y algunos parámetros variables, con el fin de dificultar o imposibilitar la recreación del mismo token por el atacante (que académico me ha quedado este párrafo ;-) ). Cuando recibamos los datos en el servidor, deberemos comprobar que el testigo se encuantra intacto en la petición, y que por lo tanto se puede garantizar la autenticidad de la petición, es decir, que esta petición la hemos generado nosotros y no la ha generado un script malintencionado. La implementación con el API de Joomla es muy sencilla. Si no tienes conocimientso sobre el API de Joomla es recomendable que te leas los tutoriales sobre desarrollo de extensiones en Joomla.

Método POST

Tenemos el siguiente formulario:

<form action="index.php" method="post">
 
	Nombre:
<input name="nombre" type="text" />
 
	Email destino:
<input name="email" type="text" />
 
	Cuerpo:
<input name="cuerpo" type="text" />
 
	<input type="submit" value="Enviar Email" />
        <?php echo JHTML::_( 'form.token' ); ?>
	<input name="option" type="hidden" value="com_prueba" />
	<input name="task" type="hidden" value="enviarEmail" />
</form>

Mediante el siguiente código:

<?php echo JHTML::_( 'form.token' ); ?>

se genera el token, que valida que realmente es el usuario el que ha enviado la petición. Después, en el task, se valida que el token sea correcto. El token, en este caso es un campo de tipo hidden con una cadena de caracteres aleatoria para cada sesión. A continuación se muestra el codigo del task enviarEmail.

   function enviarEmail(){
      JRequest::checkToken() or die( 'Token invalido' );
 
      echo "email enviado!!";
   }

Si todo a funcionado correctamente, se mostrará un mensaje por pantalla indicando que el email a sido enviado correctamente. En caso de que la petición haya sido creada desde un sitio diferente que no sea la página de administración de Joomla aparecerá un mensaje advirtiendonos que el Token es invalido, y se interrumpirá la aplicación. La comprobación la realiza el método checkToken, que genera el mismo Token y lo compara con el que viene desde el cliente, en caso de ser diferentes se cancela la ejecución del script.

Método GET

Para usar los tokens con el método GET se hace usando el objeto JUtility. A continuación se muetsra el código de una típica tabla donde se muestra una lista de usuarios con enlaces para borrar cada usuario, muy tipico.

<table border="0">
<tbody>
<tr>
  <td>
	David
  </td>
  <td>
	<a href="<?php echo JRoute::_( 'index.php?option=com_prueba&amp;task=eliminar&amp;usuario=David&'. JUtility::getToken() .'=1' ); ?>">Eliminar</a>
  </td>
</tr>
<tr>
  <td>
	Pepe
  </td>
  <td>
	<a href="<?php echo JRoute::_( 'index.php?option=com_prueba&amp;task=eliminar&amp;usuario=Pepe&'. JUtility::getToken() .'=1' ); ?>">Eliminar</a>
  </td>
</tr>
<tr>
  <td>
	Juan
  </td>
  <td>
	<a href="<?php echo JRoute::_( 'index.php?option=com_prueba&amp;task=eliminar&usuario=Juan' ); ?>">Eliminar</a>
  </td>
</tr>
</tbody>
</table>

La orden de borrar se envía al task eliminar. A continuación se muestra el código.

	function eliminar(){
		JRequest::checkToken( 'get' ) or die( 'Token invalido' );
		echo "Usuario eliminado!!";
	}

Una vez introducida la protección en el task, si alguien intenta enviar una dirección del estilo “index.php?option=com_prueba&task=eliminar&usuario=Juan”, obtendrá el mensaje “Token invalido”, de hecho, si intentas eliminar a Juan, como no se le ha introducido el token, dará error y no será borrado.

Conclusión

Usando este método solventaremos casi todos los problemas de Cross Site Request Forgery y spoofing que nos podamos encontrar, y es muy recomendable (yo diría que obligado) utilizar está tecnica, que resulta muy sencilla y fácil de implementar. Descargar código de componente con el ejemplo.

Vía Documentación oficial de Joomla

PHP Scaffolding

Phpscaffold es una aplicación online muy útil si eres desarrollador  PHP y MySQL. Se trata de una aplicación de scaffolding, que, para el que no lo sepa, es una técnica de programación que se basa en generar código de programación a partir de información de la base de datos. Es decir, mediante el esquema de la base de datos es capaz de generar código capaz de introducir, leer, modificar y eleminimar (CRUD) valores de la base de esa base de datos.

La aplicación pide las sentencias SQL necesarias para crear las tablas y a partir de ahí genera el código PHP. Estas sentencias SQL son muy fáciles de obtener a partir de phpMyAdmin,exportando la tabla. Luego solo habrá que configurar el config.php adecuadamente y listo. Ya tenemos el código CRUD generado, ahora si quieres lo puedes personalizar, añadir CSS, etc.. pero el trabajo sucio ya está hecho… una maravilla.

Estas técnicas son muy utilizadas en Frameworks como CakePHP o ruby on rails, y la verdad es que acelera mucho el desarrollo y le resta monotonía.

Yo suelo programar muchos componentes en Joomla y he hechado esta caracteristica mucho de menos, por lo que el otro día me puse a hacer unos scripts en bash para Linux que automatizan este proceso, y generan componentes de Joomla. Dentro de poco espero tenerlo acabado y lo subiré para que el que quiera lo pueda usar.

Enlace: http://www.phpscaffold.com/

Últimamente me ha dado por ponerme un poco al día en C#, y es que la noticia de que Micrososft haya liberado el framework ASP.NET MVC bajo licencia MS-PL, es decir, como software libre, me ha motivado bastante para ponerme con esta tecnología. Pero antes de entrar al trapo con ASP.NET MVC, he querido echar un vistazo a las alternativas de BBDD de las que disponía para programar con Mono en Linux.

Después de mirar los diferentes SGBD de que disponía decidí quedarme con MySQL, porque que estoy muy familiarizado ya que en PHP casi siempre me ha tocado usar esta base de datos. Postgre SQL me ha parecido me ha parecido una alternativa muy buena a MySQL, sobre todo después de la incertidumbre que se me ha generado después de la compra de Sun por parte de Oracle.

Para conectar con MySQL desde .NET lo primero que hay que hacer es bajarse el conector desde el sitio web de MySQL. Yo he bajado la versión 5.2, aunque ya van por la 6.0. Bajaros el que pone “Windows Binaries, no installer ”, estos son los binarios compilados para Windows del conector,es decir, el ensamblado, o dll, como quieras llamarlo.

No te asustes, que aunque estén compilados para Windows, Mono es compatible con estos binarios.

Una vez descargado el fichero lo descomprimes y lo que nos interesa es el directorio “bin”, donde se encuentra la dll del conector.

Ahora hay que instalar el ensamblado en la caché de ensamblados global de Mono, esto se hace con la utilidad gacutil, para ello usamos el comando:

sudo gacutil -i MySql.Data.dll

Se supone que se ha descomprimido el paquete del conector y se tiene acceso al directorio bin, donde se encuentra el fichero MySql.Data.dll.

Ahora ya se encuentra instalado el ensamblado en el entorno Mono.

Lo siguiente es abrir monodevelop y crear un nuevo proyecto, yo lo he creado de consola. Hace poco escribí un post donde puse un vídeo con el proceso de instalación de monodevelop en Suse Linux 11.1, por si te lías con la instalación.

Crear un proyecto de consola en Monodevelop

Ahora pinchamos con el botón derecho del ratón sobre el directorio Referencias->Editar Referencias.

Agregar referencia a System.Data

Hay que agregar el ensamblado del conector que acabamos de descargar y una referencia a la librería System.Data de .NET para trabajar con bases de datos.

Agregar el ensamblado del conector MySQL en Monodevelop

Ahora ya podemos comenzar a programar usando el conector de MySQL desde Mono. Yo he creado una base de datos llamada “NET” y he creado una tabla dentro de ella, a continuación pongo el código SQL necesario para crear la tabla.

CREATE DATABASE `NET` ;
CREATE TABLE `NET`.`miTabla` (
`id` INT NOT NULL AUTO_INCREMENT ,
`cuerpo` VARCHAR( 300 ) NOT NULL ,
PRIMARY KEY ( `id` )
) ENGINE = MYISAM ;
INSERT INTO `NET`.`miTabla` (
`id` ,
`cuerpo`
)
VALUES (
NULL , 'datos de prueba, 1'
), (
NULL , 'más datos de prueba, 2'
);

El ejemplo que he creado es muy simple, uso un Reader para obtener los datos de la tabla, lo recorro y lo imprimo por la pantalla.

A continuación pongo el código.

using System;
using System.Data;
using MySql.Data.MySqlClient;
namespace pruebaMySQL
{
	class MainClass
	{
		public static void Main(string[] args)
		{
			string connectionString = "Server=localhost;Database=NET;User ID=root;Password=;Pooling=false;";
  			MySqlConnection conn = new MySqlConnection(connectionString);
 
        	string query = "SELECT id,cuerpo FROM miTabla";
 
			conn.Open();
 
           MySqlCommand myCommand = new MySqlCommand(query, conn);
           MySqlDataReader myReader = myCommand.ExecuteReader();
 
           while (myReader.Read())
           {
			Console.Write("El ID es: " + myReader["id"].ToString());
			Console.WriteLine("  El cuerpo es: " + myReader["cuerpo"].ToString());
 
           }
           myReader.Close();
           myCommand.Dispose();
           conn.Close();
		}
	}
}

Se han añadido los espacios de nombres a : System.Data y MySql.Data.MySqlClient, necesarios para trabajar con el conector de MySQL sin tener que estar poniendo siempre la ruta completa de cada objeto.

En la connectionString se ha de poner la cadena con este formato siempre a piñón fijo, sustituyendo los valores dependiendo del servidor y base de datos que quieras consultar. En el objeto myReader se almacena el resultado de la consulta, que se ejecuta con el método ExecuteReader del objeto mySqlCommand, que a su vez necesita una conexión con el servidor (objeto mySqlConnection) y una string que contenga la consulta SQL que se desea realizar (query). Como se puede comprobar es muy sencillo.

Es importante cerrar el reader con el método Close, ejecutar el método Dispose del objeto myCommand para liberar memoria, y cerrar la conexión (objeto conn) con el método Close, para cerrar el socket con el servidor de MySQL y colapsarlo.

Por último, pulsamos F5 y …

Ejecución del programa

Esta vez voy a anotar un pequeño trozo de código que me ha servido de mucho en mi último trabajo.

No es ningún secreto saber cómo se listan los directorios, pero gracias al API de de Joomla! es mucho más sencillo, además se integra con la capa FTP para solucionar problemas cuando no tengamos permisos de escritura en nuestro script.

Para listar los directorios simplemente puse en siguiente código en el fichero view.html.php de mi componente:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

jimport( 'joomla.filesystem.folder' );
//Importamos los ficheros necesarios
 
$carpetas = JFolder::folders(JPATH_COMPONENT.DS.'miDirectorio');
 
//Obtenemos los directorios, el metodo folders devuelve un array con el nombre de los //directorios
 
if(count($carpetas > 0))
{
    foreach ($carpetas as $carpeta)
    {
	       	echo "Nombre del directorio: " . $carpeta ;
    }
}else{
	echo "No hay directorios en ".  JPATH_COMPONENT.DS.'miDirectorio';
}

Ahora veamos como hacer lo mismo con php sin usar el framework:

(código sacado de la web www.desarrolloweb.com )

$ruta = /path/a/tu/directorio
   // abrir un directorio y listarlo recursivo
   if (is_dir($ruta)) {
      if ($dh = opendir($ruta)) {
         while (($file = readdir($dh)) !== false) {
            //esta línea la utilizaríamos si queremos listar todo lo que hay en el directorio
            //mostraría tanto archivos como directorios
            //echo "Nombre de archivo: $file : Es un: " . filetype($ruta . $file);
            if (is_dir($ruta . $file) && $file!="." && $file!=".."){
               //solo si el archivo es un directorio, distinto que "." y ".."
               echo "Directorio: $ruta$file";
               listar_directorios_ruta($ruta . $file . "/");
            }
         }
      closedir($dh);
      }
   }else
      echo "No es ruta valida";
}

Como puedes ver, se comprueba manualmente si el directorio existe con la función is_dir(), esto ya lo lleva implementado el API de Joomla y no hace falta que lo volvamos a hacer si usamos el método folders.

Este es el código del método folders:

function folders($path, $filter = '.', $recurse = false, $fullpath = false, $exclude = array('.svn', 'CVS'))
	{
		// Initialize variables
		$arr = array ();
 
		// Check to make sure the path valid and clean
		$path = JPath::clean($path);
 
		// Is the path a folder?
		if (!is_dir($path)) {
			JError::raiseWarning(21, 'JFolder::folder: '.JText::_('Path is not a folder').' '.$path);
			return false;
		}
 
		// read the source directory
		$handle = opendir($path);
		while (($file = readdir($handle)) !== false)
		{
			$dir = $path.DS.$file;
			$isDir = is_dir($dir);
			if (($file != '.') && ($file != '..') && (!in_array($file, $exclude)) && $isDir) {
				// removes SVN directores from list
				if (preg_match("/$filter/", $file)) {
					if ($fullpath) {
						$arr[] = $dir;
					} else {
						$arr[] = $file;
					}
				}
				if ($recurse) {
					if (is_integer($recurse)) {
						$recurse--;
					}
					$arr2 = JFolder::folders($dir, $filter, $recurse, $fullpath);
					$arr = array_merge($arr, $arr2);
				}
			}
		}
		closedir($handle);
 
		asort($arr);
		return $arr;
	}

Como puedes comprobar se hacen todo tipo de comprobaciones y nos libra de realizarlas a mano.

Puedes ver más métodos interesantes en la documentación oficial del API de Joomla

Después de un largo tiempo sin escribir por motivos de trabajo, vuelvo al blog. Hoy voy a anotar un truco con jQuery que puede ahorrarnos mucho código: la función toogle.
La función toogle actúa como un interruptor, de manera que acepta dos parámetros, que serán dos funciones, una para cuando actives el interruptor y otra para cuando lo desactives.

Vamos a ver un ejemplo en el cual añadiremos una clase css a un div pulsando en un botón, de manera que cuando pinchemos en el botón , el div pasará a tener un color de fondo rojo y cuando volvamos a pulsar, el color de fondo desaparecerá.

Vamos a ver el ejemplo:

Primero creamos la clase css:

.rojo{
background:red;
width:200px;
height:300px;
}

Después introducimos el siguiente código javascript en en el head de nuestro documento html:

<script type="text/javascript">
 
$(document).ready(function() {
$('#conmutador').toggle(function() {
$('#contenedor').addClass('rojo');
}, function() {
$('#contenedor').removeClass('rojo');
});
});
</script>

Usamos los selectores de jQuery para obtener el objeto con id conmutador y le aplicacamos la función toogle.

Y este es el código html que va dentro del body:

<h1>Pruebas de jQuery</h1>
 
<button id="conmutador">Conmutador</button>
<div id="contenedor"></div>

Ya tenemos nuestro interruptor en javascript con unas pocas líneas de código.