A través de los comentarios he conocido Mylyn, una herramienta para integrar los gestores de incidencias en Eclipse, el IDE que utilizo para desarrollar.

Para completar el círculo, y como Bug Tracker utilizaré Mantis, un gestor de incidencias desarrollado en PHP que utiliza MySQL como motor de bases de datos. Podría haberme decantado por Bugzilla, Jira o Trac, pero el hecho de conocer ya el funcionamiento de Mantis, así como que esté desarrollado en PHP, han decantado la balanza. Quizás no sea el mejor, pero para lo que necesito por el momento, cumplirá su función.

La instalación

Instalando Mantis

Empezaremos instalando el gestor de incidencias Mantis. Para ello, nos bajamos la última versión estable del proyecto (en estos momentos, la 1.1.8), desde aquí: http://www.mantisbt.org/download.php

La instalación de Mantis es sencilla:

1. Creamos la base de datos que utilizará la aplicación en MySQL.

2. Modificamos el archivo config_inc.php.sample, concretamente a partir de la línea 40:

# --- database variables ---------

# set these values to match your setup
$g_hostname      = "localhost";
$g_db_username   = "mantisdbuser";
$g_db_password   = "";
$g_database_name = "bugtracker";
$g_db_type       = "mysql";

# --- email variables -------------
$g_administrator_email  = 'administrator@example.com';
$g_webmaster_email      = 'webmaster@example.com';

# the "From: " field in emails
$g_from_email           = 'noreply@example.com';

# the return address for bounced mail
$g_return_path_email    = 'admin@example.com';

Las variables $g_hostname, $g_db_username, $g_db_password y $g_database_name, son las típicas de cualquier configuración para conectar con MySQL. $g_db_type por su parte, lo dejaremos tal cual está, ya que por el momento tan solo soporta mysql.

Las cuentas de email de las líneas inferiores, las configuraremos al gusto, para el envío-recepción de los emails correspondientes.

3. Una vez finalizada la modificación de este archivo, guardamos los cambios y lo renombramos. Quitaremos el .sample del final, para quedarnos tan solo con config_inc.php.

4. Ya hemos terminado la configuración. Ahora tan solo tendremos que seguir los pasos de la instalación, que se realiza desde http://servidor-mantis.com/admin/install.php.

5. Por último, y como medida de seguridad, es recomendable eliminar del servidor la carpeta admin.

Instalando Mylyn en Eclipse

El siguiente paso es instalar Mylyn en Eclipse. Como siempre, nos vamos al menú Help > Install New Software, y añadimos esta url: http://download.eclipse.org/tools/mylyn/update/e3.4/. Seleccionamos los complementos deseados (en Mylyn Integration podéis desmarcar el de C/C++ y Java si nos los vais a necesitar) y continuamos hasta finalizar la instalación. Reiniciamos Eclipse y seguimos

Conectando Mylyn con Mantis

Para acabar, instalaremos el plugin Mylyn-Mantis, necesario para que Mylyn reconozca las incidencias generadas en Mantis. Para ello, seguimos los mismos pasos que hemos realizado para instalar Mylyn, recogiendo los paquetes necesarios de esta url: http://mylyn-mantis.sourceforge.net/eclipse/update/. Instalamos el conector y volvemos a reiniciar Eclipse.

Importar las incidencias de Mantis a Eclipse

Ya solo nos queda conectar Mylyn con el servidor donde hemos instalado Mantis. Para ello, mostramos el panel Task List en Eclipse desde Window > Show View > Other, y dentro de la carpeta Tasks, encontraremos Task List. Es importante no confundir este panel con el propio de Eclipse, Tasks, ya que no tienen la misma utilidad. El nativo de Eclipse recoge los TO-DO, DONE, etc. que marcamos en el código.

Pinchamos con el botón derecho sobre el panel, y seleccionamos New > Query.

A continuación, seleccionamos Add Task Repository, y seleccionamos el de Mantis.

En la ventana que nos aparece a continuación, seleccionaremos en el desplegable Server la opción Mantis Connector 1.1.0 or greater, modificamos la url que nos aparecerá en su lugar (http://your.domain.com/api/soap/mantisconnect.php) por la de nuestro servidor, y terminamos de configurar el resto de parámetros (incluido nuestro usuario de Mantis).

Para finalizar, le damos un nombre a la Query, seleccionamos el proyecto creado en Mantis del cual queremos importar las incidencias, y seleccionamos un filtro (lo más lógico es elegir uno que devuelva todas las incidencias de ese proyecto abiertas asignadas a nuestro usuario).

Para crear un filtro, podemos hacerlo desde el propio Mantis realizando una búsqueda avanzada.

Finalizamos el proceso, y ya es el propio Mylyn quien se encarga de importar todas las incidencias que cumplan el filtro a nuestro Eclipse.

Ahora tan solo nos queda trastear con él para explotar todas sus posibilidades.

Seguiremos informando

En programania, Luis Artola ha publicado el enlace a una presentación de Stefan Esser acerca de la seguridad en Zend Framework que corresponde a la presentación que ofreció en la Dutch PHP Conference el pasado mes de Junio.

Muy interesante para todos los que andamos tocando Zend Framework, pues se tratan temas importantes como son:

• XSS
• CSRF
• Seguridad en consultas SQL
• Validación y filtrado de las entradas
• Manejo de las sesiones

No entra en profundidad en ningún tema (al menos en las diapositivas), pero puede ser un buen punto de partida.

Descargar presentación: Secure Programming With The Zend Framework [PDF]

Vía | programania.net

Es este artículo, se utilizan 3 métodos distintos:

• JSON (json_encode y json_decode)
• Serialization (serialize y unserialize)
• var_export / include (var_export y include)

La prueba para obtener a un ganador entre estos tres métodos fué la siguente:

Se utilizaron 5 conjuntos de datos, con diferentes tamaños (de memoria utilizada): 904B, ~18kB, ~250kB, ~4.5MB and ~72.5MB.

A estos conjuntos se los sometió a 10 codificaciones/decodificaciones, calculando el tamaño del archivo generado, y el tiempo tardado en relaizar cada operación.

Click para ampliar

Los resultados son bastante reveladores:

1. El método con mayor ratio de compresión es JSON.
2. Hasta que no lidiamos con cantidades “ingentes” de datos ( más de 30Mb), los mejores resultados se obtienen con serialize/unserialize.
3. A partir de los 30Mb, el rendimiento de serialize/unserialize disminuye casi exponencialmente.
4. A partir de los 30Mb, JSON se convierte en el método más eficaz.

Más información sobre cómo y dónde se realizó la comparativa, así como más gráficas, en el artículo original: Cache a large array JSON serialize or var_export

Sin embargo, utilizar este método nos obliga a solicitar el nombre de usuario y la contraseña a todos aquellos que quieran acceder al servicio. Esta práctica, aparte de estar desaconsejada como se indica en la documentación del API, en un futuro cercano estará obsoleta, y no se permitirá el acceso al API utilizandola.

Para compensarlo, los chicos de Twitter han adoptado OAuth, un estándar abierto que permite la identificación del usuario sin que el servicio externo maneje contraseñas ni otra información sensible requerida para la identificación.

En Zend Framework disponemos desde hace varios meses de Zend_Oauth, un proyecto de Pádraic Brady, que se encuentra todavía en la incubadora, y teóricamente no debería de tardar mucho en dar el salto a la versión final del framework.

Para poder utilizar OAuth en nuestro proyecto basado en Twitter desarrollado con el framework de Zend, debemos:

1. Registrar nuestra aplicación en Twitter.
2. Descargar Zend_Oauth del incubator de Zend Framework.

Registrando la aplicación en Twitter.

Para registrar nuestra aplicación en Twitter, debemos hacerlo desde esta página: http://twitter.com/oauth_clients/. Desde allí podremos registrar una nueva aplicación para utilizar el servicio, así como administrar aquellas que ya tenemos registradas.

Captura 1. Desde esta página registraremos nuestra aplicación en Twitter para utilizar OAuth para la identificación.

Rellenaremos el formulario, prestando un especial interés en los campos Application Type, Callback URL y Default Access type.

Con Application Type definiremos que tipo de aplicación va a realizar las peticiones de identificación, si una aplicación de escritorio o un servicio web. En nuestro caso lo tenemos bastante fácil: marcaremos Browser.

En Callback URL debemos insertar la url a la que redirigirá Twitter al usuario una vez se ha completado la identificación. Si tan solo queremos hacer unas cuantas pruebas, un http://localhost/oauth-test/ nos bastará. O si jugamos con los Virtual Servers de Apache, podemos crearnos nuestro propio dominio de desarrollo. Algo parecido a http://twitterOauth.dev/.

Default Access type lo marcaremos como Read & Write. Una vez identificados, tendremos que hacer algo para que comprobar que realmente funciona, ¿no? Si elegimos Read-only, no seremos capaces de, por ejemplo, actualizar el timeline del usuario; tan solo podremos recibir información, no enviarla.

Para finalizar, marcamos la opción Use Twitter for login.

Una vez creada la aplicación, podremos ver los datos de conexión que necesitamos para identificarnos a través de OAuth.

Captura 2. Estos son los datos de conexión nuestra aplicación. Los utilizaremos más adelante con Zend_Oauth para identificarnos.

Descargando Zend_Oauth

Con nuestra aplicación ya registrada en el servicio de Twitter, vamos a realizar algunas pruebas desde nuestro proyecto de Zend Framework.

Para ello, debemos descargar Zend_Oauth del repositorio de la incubadora de Zend. Para ello, nos valdremos de cualquier cliente de Subversion. TortoiseSVN para windows o  SCPlugin para Mac OS X, deberían bastarnos.

La url del repositorio para descargar Zend_Oauth es: http://framework.zend.com/svn/framework/standard/incubator/library/Zend/Oauth.

Descargaremos la HEAD Revision, en formato recursivo, para obtener todos los archivos necesarios.

Captura 3. Estos son los archivos y carpetas que componen Zend_Oauth, descargados del repositorio de Zend

Copiamos el archivo Oauth.php y la carpeta Oauth a la librería de Zend, que normalmente está en /library/Zend/.

Doy por supuesto que tienes unos conocimientos mínimos de Zend Framework,y por lo tanto, sabes como crear y configurar un proyecto desde cero. Sino es así, puedes seguir el Quickstart disponible en la documentación que Zend dispone.

Conectando con twitter

A partir de aquí, los pasos son sencillos.Utilizaremos el indexController.php para realizar la conexión.

/**
* Archivo indexController.php
* application/controllers/indexController.php
*/
class indexController extends Zend_Controller_Action
{

public function indexAction()
{

require_once 'Zend/Oauth/Consumer.php';

$options = array(
'requestScheme' => Zend_Oauth::REQUEST_SCHEME_HEADER,
'version' => '1.0',
'signatureMethod' => 'HMAC-SHA1',
'localUrl' => 'http://twitterOauth.dev/',
'requestTokenUrl' => 'https://twitter.com/oauth/request_token',
'userAuthorisationUrl' => 'https://twitter.com/oauth/authorize',
'accessTokenUrl' => 'https://twitter.com/oauth/access_token',
'consumerKey' => 'CONSUMER_KEY',
'consumerSecret' => 'CONSUMER_SECRET'
);

$consumer = new Zend_Oauth_Consumer($options);

if (!isset($_SESSION['ACCESS_TOKEN'])) {
if (!empty($_GET)) {
$token = $consumer->getAccessToken($_GET, unserialize($_SESSION['REQUEST_TOKEN']));
$_SESSION['ACCESS_TOKEN'] = serialize($token);
} else {
$token = $consumer->getRequestToken();
$_SESSION['REQUEST_TOKEN'] = serialize($token);
$consumer->redirect();
}
} else {
$token = unserialize($_SESSION['ACCESS_TOKEN']);
// Reinicia el ACCESS_TOKEN cada vez que recargamos
$_SESSION['ACCESS_TOKEN'] = null;
}

$xml = simplexml_load_file('http://twitter.com/users/show.xml?user_id=ID_DEL_USUARIO');
echo var_dump($xml);
}
}

Vamos a repasar el código:

require_once 'Zend/Oauth/Consumer.php';

$options = array(
'requestScheme' => Zend_Oauth::REQUEST_SCHEME_HEADER,
'version' => '1.0',
'signatureMethod' => 'HMAC-SHA1',
'localUrl' => 'http://twitterOauth.dev/',
'requestTokenUrl' => 'https://twitter.com/oauth/request_token',
'userAuthorisationUrl' => 'https://twitter.com/oauth/authorize',
'accessTokenUrl' => 'https://twitter.com/oauth/access_token',
'consumerKey' => 'CONSUMER_KEY',
'consumerSecret' => 'CONSUMER_SECRET'
);

Cargamos los archivos necesarios para el correcto funcionamiento de Zend_Oauth. En este caso, bastará con el archivo Consumer.php dentro de Zend/Oauth/.
Creamos un array con los datos necesarios para la conexión.
Los datos que necesitamos personalizar con la información que nos proporcionó Twitter cuando registramos la aplicación son:

• localUrl (l. 7). Donde definiremos la url a la que se redirigirá al usuario una vez completado el proceso de identificación.
• consumerKey (l. 11) y consumerSecret (l.12) corresponden a los campos con los mismos nombres que nos entrega Twitter (ver captura 2).

$consumer = new Zend_Oauth_Consumer($options);

if (!isset($_SESSION['ACCESS_TOKEN'])) {
if (!empty($_GET)) {
$token = $consumer->getAccessToken($_GET, unserialize($_SESSION['REQUEST_TOKEN']));
$_SESSION['ACCESS_TOKEN'] = serialize($token);
} else {
$token = $consumer->getRequestToken();
$_SESSION['REQUEST_TOKEN'] = serialize($token);
$consumer->redirect();
}
} else {
$token = unserialize($_SESSION['ACCESS_TOKEN']);
// Reinicia el ACCESS_TOKEN cada vez que recargamos
$_SESSION['ACCESS_TOKEN'] = null;
}

Realizamos la conexión y almacenamos los datos en la sesión. La variable $token almacenará una serie de parámetros con el siguiente formato:

oauth_token = CODIGO_ALFANUM & oauth_token_secret = CODIGO_ALFANUM &  user_id = ID_DEL_USUARIO_LOGUEADO & screen_name = NOMBRE_DEL_USUARIO

Por supuesto, sin espacios entre caracteres. Podremos dividir esta cadena utilizando la función explode() de PHP, para obtener el id del usuario, que deberíamos almacenar en la sesión para futuras consultas a twitter y obtener datos, como por ejemplo, la ficha completa del usuario.

$xml = simplexml_load_file('http://twitter.com/users/show.xml?user_id=ID_DEL_USUARIO');
echo var_dump($xml)

El API de twitter permite obtener los resultados en formato XML o JSON. Para este ejemplo he optado por la vía rápida, y usar simplexml para recoger los valores y mostrarlos. Estar parte es personalmente optimizable por el lector

Ahora solo nos queda probar nuestra aplicación. Recomiendo desactivar firewalls y demás protecciones que podamos tener instaladas en nuestro sistema para realizar las pruebas. Personalmente, utilizo Little Snitch para Mac OS X, y no hay forma de realizar la conexión sin desactivarlo.

Si ejecutamos nuestro script, comprobamos que el navegador nos redirige a twitter, donde nos aparecerá el siguiente mensaje, informándonos de la aplicación que solicita nuestra identificación:

Desde la página de Twitter, se nos ofrece información de la aplicación que solicita que nos identifiquemos.

Una vez permitimos el acceso a la aplicación, Twitter nos redirigirá automáticamente de vuelta a la aplicación, con la información justa y necesaria del usuario: su nombre y su id.

Aún en Twitter, después de identificarnos se nos avisa que nos devuelve, sanos y salvos, a la aplicación de origen.

Ahora, ya podemos realizar todas las consultas necesarias a la API de Twitter.

Cabe resaltar que no podremos utilizar Zend_Service_Twitter si utilizamos el sistema de identificación con OAuth, ya que este necesita del nombre de usuario y contraseña para realizar la conexión. Así que, mientras tanto, deberemos conformarnos con recibir los datos en XML o JSON, según nos sea conveniente.

Esperemos que cuando Zend_Oauth se incorpore definitivamente a Zend Framework, modifiquen el helper de Twitter para poder utilizarlos conjuntamente. Ya estoy impaciente…

]]> http://blog.joanfernandez.es/2009/07/login-en-twitter-con-zend-framework-y-zend_oauth/feed/ 2 http://blog.joanfernandez.es/2009/06/google-te-ayuda-a-optimizar-tu-codigo-php/ http://blog.joanfernandez.es/2009/06/google-te-ayuda-a-optimizar-tu-codigo-php/#comments Fri, 26 Jun 2009 19:18:59 +0000 Joan http://blog.joanfernandez.es/?p=203

ACTUALIZADO.

En Baluart.net encontramos una recopilación de las correcciones que la comunidad de usuarios de PHP ha hecho al artículo publicado por Google que se comenta en esta entrada.

Es importante que leas el artículo, pues rebaten muchas de las afirmaciones con códigos de ejemplo y tiempos de ejecución. Así, sabrás realmente a qué acogerte a la hora de programar.

Es curioso saber que los programadores de Google también se equivocan

Si hace un par de días comentabamos unos consejos para optimizar javascript, hoy le toca el turno a PHP.

De la mano de Google y su nueva sección Let’s make the web faster, encontramos PHP performance tips, una recopilación de consejos para programadores de PHP que nos ayudarán a mantener nuestros sitios más rápidos y optimizados.

Veamos algunos de los consejos que Eric Higgins, Webmaster de Google, nos ofrece:

Mantén actualizada tu versión de PHP.

¿Aún sigues utilizando PHP4? Las nuevas versiones de PHP están optimizadas para mejorar su rendimiento, por lo que deberías, al menos, dar el salto a PHP5. Hoy en día la mayoría de servicios de hosting ya ofrecen servidores con PHP5 instalado, para que puedas migrar tus páginas sin miedos.

Utiliza la caché en tus sitios.

Utilizando un modulo para cachear los resultados como Memcache, o mediante un sistema de templates que lo soporte, como Smarty, podemos mejorar la velocidad de nuestras páginas cacheando los resultados de las consultas a la base de datos, o las páginas renderizadas.

Utiliza el buffer de salida.

PHP utiliza un buffer de salida para almacenar toda la información que tratamos de imprimir desde nuestros scripts. Este buffer puede disminuir el rendimiento de nuestras páginas, ya que no muestra la información al usuario hasta que no se llena.

Afortunadamente, podemos modificar el comportamiento del buffer para que muestre los datos más frecuentemente.

Más info sobre el buffer de salida de PHP.

Usa comillas simples para los strings.

A la hora de delimitar un string, PHP permite hacerlo de dos formas diferentes; utilizando ‘comillas simples’ o “comillas dobles”. Sin embargo, existen diferencias entre ambos métodos. Si utilizamos comillas dobles, PHP buscará variables dentro de la cadena, y si las encuentra, insertará su valor correspondiente. Esto puede significar una bajada de rendimiento, sobre todo si utilizamos strings sin variables dentro.

Sustituye los print por echo.

El rendimiento de la función echo es mayor que el de print. Además, la función echo puede recibir un número ilimitado de parámetros, por lo que no es necesario concatenar el string que le pasamos a la función. Es decir:

$uno = 1;
$dos = 2;
$tres = 3;
// Típica concatenación para utilizar con echo
echo 'Vamos a contar hasta tres: ' . $uno . ' ' . $dos . ' y ' . $tres;

// Sin embargo, no necesitamos concatenar la cadena
// antes de pasarla a echo, puesto que esta función
// puede recibir el número de parámetros que
// deseemos
echo 'Vamos a contar hasta tres: ', $uno, ' ', $dos, ' y ', $tres;

// Y el resultado, en ambos casos será el mismo:
// "Vamos a contar hasta tres: 1 2 y 3"

En el ejemplo anterior el resultado es exactamente el mismo, y sin embargo evitamos la carga de tener que concatenar el string antes de pasar la cadena al buffer de salida.

Leer el artículo completo en Google Code.