Armetiz

Pour travailler dans de bonne condition avec Symfony2, il vous faut l’extension intl.

Voici la démarche à suivre pour l’installer avec pear.

installer un compilateur C++ & les libraries libicu-devel libicu

yum install gcc-c++ libicu libicu-devel

pear channel-update pear.php.net
pear upgrade PEAR
pecl channel-update pecl.php.net
pear install intl

Créer le fichier /etc/php.d/intl.ini et ajouter

extension=intl.so

Made in Montréal

Outil d’exploration basé sur une application RIA utilisant la technologie Flash d’Adobe.
MadeinMTL.com regorge d’informations sur les bons coins de Montréal.

Le site n’est pas tout jeune, il a été ouvert en 2003, et une nouvelle version de leur application à vu le jour récemment.
Quand on regarde la partie « A propos« , nous observons :

MadeinMTL permet l’exploration virtuelle de Montréal, â travers plus de 15 000 photos, 400 textes, 50 heures de vidéo, 40 capsules sonores et 25 courts-métrages, intégrés dans un environnement organique, qui traduit l’expérience véritable que nous avons d’une ville en y habitant ou en la visitant.

PS : L’article était en brouillon sur mon blog depuis 2008.

Mise en situation :

• Application_A.swf est une application autonome qui utilise les Flashvar.
• Application_Preloader.swf est un preloader qui va charger Application_A.swf.

L’objectif c’est de pouvoir utiliser les Flashvar avec Application_Preloader.swf pour qu’elles soient transmises à Application_A.swf.

Pour cela, nous allons utiliser une instance de URLVariables que l’on passera à URLRequest.

var _urlRequest		: URLRequest	= new URLRequest ( "http://www.domain.tld/Application_A.swf" );
var _urlVariables	: URLVariables	= new URLVariables ();
var _loader		: Loader	= new Loader ();
 
for (var property : String in loaderInfo.parameters ) 
{
	_urlVariables[property]	= loaderInfo.parameters[property];
}
 
_urlRequest.method	= URLRequestMethod.GET;
_urlRequest.data	= _urlVariables;
 
_loader		= new Loader ();
_loader.load ( _urlRequest );

Ce petit programme permet d’afficher la camera d’une personne qui se connecte. Cela est fait grâce à l’utilisation d’un flux NetStream lui même utilisant une connexion P2P sans serveur.

A noter que cela n’est absolument pas optimisé. Si vous avez des conseils à donner sur la configuration du NetStream, NetConnection, NetGroup ou encore du GroupSpecifier pour améliorer les performances, n’hésitez pas..

private var nc			: NetConnection;
private var group		: NetGroup;
private var connected	: Boolean;
private var sendStream	: NetStream;
private var listenStreams	: Object;
private var groupspec	: GroupSpecifier;
private var listenStream	: NetStream;
private var id 			: String;
 
public function WebcamP2P()
{
	super();
 
	stage.align 		= StageAlign.TOP_LEFT;
	stage.scaleMode 	= StageScaleMode.NO_SCALE;
 
	id	= String ( ( new Date () ).time * int ( Math.random() * 1000 ) );
 
	nc = new NetConnection ();
	nc.addEventListener(NetStatusEvent.NET_STATUS, netStatus);
	nc.connect("rtmfp:");
}
 
private function netStatus (event:NetStatusEvent):void
{
	switch(event.info.code){
		case "NetConnection.Connect.Success":
			setupGroup();
			break;
		case "NetGroup.Connect.Success":
			connected = true;
			break;
		case "NetGroup.MulticastStream.PublishNotify":
			trace ( "name of the detected stream : " + event.info.name);
 
			var _video			: Video;
			var _listenStream	: NetStream;
 
			_video 	= new Video ( 320, 240 );
			_listenStream	= new NetStream ( nc, groupspec.groupspecWithoutAuthorizations() );
			_listenStream.play ( event.info.name );
 
			_video.attachNetStream ( _listenStream );
 
			addChild ( _video );
			break;
	}
}
 
private function setupGroup():void
{
	groupspec = new GroupSpecifier("myGroup/groupOne");
	groupspec.postingEnabled 	= false;
	groupspec.multicastEnabled 	= true;
	groupspec.ipMulticastMemberUpdatesEnabled = true;
	groupspec.routingEnabled	= false;
	groupspec.addIPMulticastAddress("225.225.0.1:30303");
 
	group = new NetGroup(nc,groupspec.groupspecWithoutAuthorizations());
	group.receiveMode			= NetGroupReceiveMode.NEAREST;
	group.replicationStrategy		= NetGroupReplicationStrategy.RAREST_FIRST;
	group.addEventListener(NetStatusEvent.NET_STATUS,netStatus);
 
	sendStream = new NetStream (nc, groupspec.groupspecWithoutAuthorizations() );
	sendStream.addEventListener(NetStatusEvent.NET_STATUS, netStreamHandler);
	sendStream.multicastAvailabilitySendToAll	= true;
	sendStream.attachAudio ( Microphone.getMicrophone() );
	sendStream.attachCamera ( Camera.getCamera () );
	sendStream.publish ( id );
}

Cette article fait suite à une incapacité technique de ma part à comprendre les comportements concernant le fonctionnement du domaine d’application.

Voici l’énoncer du problème, nous avons deux fichiers SWF présents sur deux domaines différents.
Nous souhaitons simplement pouvoir utiliser une librairie partagée entre ces deux SWF et donc utiliser des définitions de classes communes.
L’objectif est donc d’utiliser un seul domaine d’application pour les deux SWF.

D’après la méthode officielle,

var _loader : Loader = new Loader ();
var _request : URLRequest = new URLRequest ( "http://www.example.com/foo.swf");
var _context : ContextLoader = new ContextLoader ();
 
_context.applicationDomain = ApplicationDomain.currentDomain;
 
_loader.load ( _request, _context );

Le problème a été retourné dans tout les sens.. nous n’avons jamais eu les mêmes domaines d’applications pour l’enfant et le parent.

De plus, il est simple de vérifier si deux SWF utilise le même domaine d’application.

trace ( String ( __loader.contentLoaderInfo.applicationDomain == ApplicationDomain.currentDomain ) ) ;
//false systématiquement

Les crossdomain sont présents sur les deux serveurs, et les utilisations de Security.allowDomain (« * »); n’ont pas été oubliées.

Aussi, le soucis reste le même lorsque nous travaillons en local et que l’on charge le SWF avec un chemin relatif.
Ce qui est étrange, c’est que dans ce cas les définitions de classes sont utilisables et donne l’impression d’un seul domaine d’application.

Du coups, j’y perds totalement mon latin. A savoir que nous avons tester avec le player 10.2.152 et 10.1

Le script suivant permet de réaliser un simple serveur TCP en Perl.
Vous pourrez accéder ensuite à ce serveur grâce à une connexion telnet.

shell>telnet 127.0.0.1 3000

Le serveur ne fait qu’afficher des informations à l’utilisateur, et retourne ce que l’utilisateur tape.
Pour terminer la connexion, l’utilisateur utilisera le mot clé : quit.

#!/usr/bin/perl -w 
 
use strict;
use IO::Socket::INET;
 
my $server = IO::Socket::INET->new ( LocalPort => 3000, Type => SOCK_STREAM, Reuse => 1, Listen => 5) or die "Probleme serveur";
my $client;
my $chaine;
my $pid;
 
$SIG{CHLD} = 'IGNORE';
 
while ( $client = $server->accept ())
{
        $pid = fork;
        unless ($pid)
        {
                while ( 1 )
                {
                        print $client "Vous voulez dire ? ";
                        $chaine = <$client>;
                        exit unless defined $chaine;
 
                        chomp ($chaine);
 
                        if ( $chaine =~ "quit" )
                        {
                                $client->shutdown ( 2 );
                                exit;
                        }
                        else
                        {
                                print $client "Vous avez dit : $chaine\n";
                        }
                }
        }
}

Explication

$SIG{CHLD} = 'IGNORE';

Le script réalise un fork pour chaque nouvel utilisateur. Lorsque l’utilisateur termine la connexion le processus fils va se terminer grâce à la commande « exit ».
Sans $SIG{CHLD} = ‘IGNORE’ le processus fils serait transformé en processus Zombie jusqu’à ce que le processus parent soit terminé. Si vous réalisez un Daemon cela risque de saturer votre table de processus.

$server->accept ()

Met en stand-by le processus jusqu’à la connexion d’un nouvel utilisateur.
Cette fonction retourne un objet de type IO::Socket.

$chaine = <$client>;

Le processus en charge du client attend que celui-ci saisisse une valeur au clavier.

$client->shutdown ( 2 );

On termine la connexion avec l’utilisateur proprement.
Le numéro 2 indique au client que l’on a fini d’utiliser le socket.
Pour plus d’information sur cette méthode, voici la Perldoc.

Cet article s’inscrit à la suite du précèdent billet : Authentification & Autorisation avec Zend AMF.

Zend_Amf_Adobe_Auth est une classe livré avec Zend 1.10. Elle peut être utilisée comme service d’authentification pour un serveur Zend_Amf_Server. Le soucis, c’est que cette classe fonctionne conjointement avec un fichier XML réputé statique.

Voici donc le code d’une classe qui permet l’authentification d’un utilisateur AMF via la base de données.
Sachant que nous développons cela pour offrir des services AMF, cette classe utilisera la logique métier implémentée au sein des services.

class Auth_AmfDatabase extends Zend_Amf_Auth_Abstract
{
    protected $_acl;
    protected $_users = array();
 
    public function __construct()
    {
        $this->_acl = new Zend_Acl();
 
        $oServiceRole	= new Service_Role ();
        $oRoles		= $oServiceRole->fetchAll ( );
 
        foreach ( $oRoles as $oRole )
        	$this->_acl->addRole ( new Zend_Acl_Role( $oRole->title ) );
    }
 
    public function getAcl()
    {
        return $this->_acl;
    }
 
    public function authenticate()
    {
        if (empty($this->_username) ||
            empty($this->_password)) {
            require_once 'Zend/Auth/Adapter/Exception.php';
            throw new Zend_Auth_Adapter_Exception('Username/password should be set');
        }
 
        $oServiceUser	= new Service_User ();
        $oUser		= $oServiceUser->authentication ( $this->_username, $this->_password );
 
        if ( null == $oUser )
        {
        	return new Zend_Auth_Result(Zend_Auth_Result::FAILURE,
                null,
                array('Username and / or Password not found')
                );
        }
        else
        {
        	$id = new stdClass();
       	 	$id->role = $oUser->role->code;
       	 	$id->name = $oUser->username;
 
        	return new Zend_Auth_Result(Zend_Auth_Result::SUCCESS, $id);
        }
    }
}

Le constructeur récupère l’ensemble des rôles existants en base de données pour peupler l’objet ACL.
La méthode authenticate va vérifier le couple Login / Password, et en cas de succès va retourner un objet Zend_Auth_Result contenant lui même un objet standard.
Cet objet standard doit avoir une propriété role et name, le rôle contiendra l’identifiant que vous avez définit dans vos autorisations ACL. Le name devra contenir le login de votre utilisateur.

Cette classe a été inspirée par Zend_Amf_Adobe_Auth. N’hésitez pas à l’adapter pour vos propres besoins.

Pour annoncer la sortie de Flash Media Server 4. Voici un petit tutoriel présentant l’installation de FMS 4 sur Debian Lenny.

Cette version sera disponible pour un plus grand nombre de machine avec le support du 64Bits. Elle permettra de réduire considérablement les coûts de bande passante pour la VoD grâce au P2P mais aussi pour le live grâce au Multicast.

Installation

L’installation se déroule sur une Debian 5.0 où il n’y a que le système de base.

FMS 4 nécessite la librairie libnspr4.

apt-get install libnspr4-dev

Ensuite, récupérer FMS 4 pour Linux.
Dé-zipper le fichier : FlashMediaServer_4_all.zip fraichement téléchargé.
Il existe deux versions pour Linux, la 32bits et la 64bits. A vous de choisir celle qui convient à votre architecture.

Pour décompresser et extraire l’archive.

tar -xzvf FlashMediaServer4.tar.gz

Lancer le script d’installation FMS qui se trouve dans le répertoire où vous avez extrait l’archive du dessus.

./installFMS

A un moment, on vous demandera un licence. Nous souhaitons utiliser la version de développement, donc nous passons cette étape en appuyant sur ENTREE et en répondant non à la question :

You have not entered a serial number. Falling back to
the Adobe Flash Media Development Server!
Would you like to try again?

Options par défaut

• Répertoire d’installation : /opt/adobe/fms
• Adobe FMS Server port : 1935 & 80
• Adobe FMS Admin Server port : 1111

Nous allons voir comment mettre en place l’authentification et l’autorisation lorsque l’on souhaite travailler avec Zend et le protocole AMF.

Au niveau des pré-requit, vous devez avoir une architecture Zend et AMF opérationnelle.
Aussi, je vous conseils de lire la documentation sur Zend_Auth et Zend_Acl.
Vous devez avoir compris la notion de rôle et de ressource.

Objectifs

Si vous fournissez des services à travers le réseau, et qu’ils peuvent avoir un impact sur la cohérence des données, vous vous devez de sécuriser l’accès à ces services.

Sécurisé l’accès signifie restreinte l’accès, mais aussi chiffrer les communications.
Nous ne traiterons pas la partie chiffrement des échanges, pour cela je vous laissez chercher de la documentation sur HTTPS.

Point de départ

Ci-dessous, un exemple de contrôleur Zend offrant des services AMF.

class ServiceController extends Zend_Controller_Action
{
    public function init()
    {
        $this->_helper->viewRenderer->setNoRender();
        $this->_helper->layout->disableLayout();
    }
 
    public function amfAction()
    {
	$server = new Zend_Amf_Server();
 
	//Liste des services
	$server->setClass( "Service_User" );
	$server->setClass( "Service_Book" );
	$server->setClass( "ZendAmfServiceBrowser" );
 
	//Mapping des objets PHP avec les objets ActionScript		
	$server->setClassMap('UserDTO', 'Model_DTO_User');
	$server->setClassMap('BookDTO', 'Model_DTO_Book');
 
	$server->setProduction(false);
 
	ZendAmfServiceBrowser::$ZEND_AMF_SERVER = $server;
 
	echo ($server->handle());
    }
}

Nous avons donc deux services, et deux types d’objets pouvant être utilisés.

Vous remarquerez l’utilisation de ZamfBrowser, ce service couplé avec une application Adobe AIR permet de travailler facilement avec les services.

Voici à quoi ressemble les prototypes d’un de mes services.

class Service_Book
{
	public function createBook (Model_DTO_Book $oBook) {}
	public function readBook (Model_DTO_Book $oBook) {}
	public function updateBook (Model_DTO_Book $oBook) {}
	public function deleteBook (Model_DTO_Book $oBook) {}
	public function isRentBy (Model_DTO_User $oUser) {}
}

L’autre service est composé lui aussi des méthodes CRUD (Create, Read, Update, Delete), ainsi que d’autres fonctions métiers.

Sachant que mon application cliente Flash utilise ces services, il est très facile à un utilisateur de découvrir l’URI de la passerelle AMF.
En l’état, une personne ayant l’accès à ma passerelle AMF pourrai utiliser toutes les fonctions de mes services. Ce qui implique qu’il puisse modifier ma base de données.

Remarquer que si l’on supprime le service de ZamfBrowser, l’utilisateur n’aura pas accès à la liste exhaustive des services. Si vous êtes en production, je vous conseils donc de supprimer ce service pour des raisons de sécurité.

Mise en place de l’authentification

Nous allons commencer par mettre en place l’authentification,
Sachant que nous utilisons un client Flash, il est logique d’utiliser Zend_Amf_Adobe_Auth.

$authAdapter = new Zend_Amf_Adobe_Auth(APPLICATION_PATH . '/config/password.xml');
$server->setAuth($authAdapter );

Avec ces deux lignes, nous avons mis en place l’authentification au niveau du serveur.
Il vous reste à définir le fichier password.xml

<?xml version="1.0"?>
<roles>
   <role id="editor">
        <user name="stephane" password="P@ssword01"/>
        <user name="robert" password="P@ssword01"/>
   </role>
</roles>

Le fichier password.xml contient les identifiants et les mots de passe des utilisateurs.
C’est à ce niveau que vous définissez les affectations d’identifiants à un rôle.

Si vous avez besoin de plus de souplesse au niveau de la gestion des identifiants, je vous conseils la lecture de Authentification avec une table de base de données.

Il est à noter, que si vous ne spécifier aucun identifiant lors de votre connexion au serveur AMF vous serez considéré comme un invité : Zend_Amf_Constants::GUEST_ROLE

Mise en place de l’autorisation

Maintenant que nous avons correctement définit l’authentification, passons à l’autorisation.
C’est maintenant que nous allons donner les autorisations ou refus d’accès aux services.

$acl = new Zend_Acl();
$server->setAcl($acl);

Avec ces deux lignes, vous avez définit une Acces Control List.
Vous le constatez, aucune autorisation n’est définit; mais il est important de noter que maintenant, plus personne n’a accès à vos services.

Pour donner l’accès à nos deux services à n’importe qui, nous allons procéder comme suit :

$acl = new Zend_Acl();
$acl->addResource ( new Zend_Acl_Resource('Service_User') );
$acl->addResource ( new Zend_Acl_Resource('Service_Book') );
$acl->addResource ( new Zend_Acl_Resource('ZendAmfServiceBrowser') );
 
$acl->allow (null, 'Service_User');
$acl->allow (null, 'Service_Book');
$acl->allow (null, 'ZendAmfServiceBrowser);
$server->setAcl($acl);

Ci-dessus, nous avons une liste explicite des autorisations.
Si nous avions voulu faire dans l’implicite, nous aurions procédé ainsi :

$acl = new Zend_Acl();
$acl->allow ();
$server->setAcl($acl);

Pour aller plus loin dans l’explication, nous allons maintenant définir l’ensemble de nos autorisations.

Nous souhaitons que le rôle administrateur est accès à tout, et nous souhaitons que les utilisateurs non authentifiés n’est pas accès aux fonctions de mise à jour.

Rappelez-vous, nous avons vu plus haut que vous étiez connecter avec le rôle invité lorsque vous ne spécifiez aucun identifiant.

$acl = new Zend_Acl();
 
//Définition les rôles.
$acl->addRole ( new Zend_Acl_Role(Zend_Amf_Constants::GUEST_ROLE) );
 
//Définition des autorisations
$acl->allow ();
$acl->deny (Zend_Amf_Constants::GUEST_ROLE, null, "create");
$acl->deny (Zend_Amf_Constants::GUEST_ROLE, null, "update");
$acl->deny (Zend_Amf_Constants::GUEST_ROLE, null, "delete");
 
$server->setAcl($acl);

Premièrement,
Nous avons dû définir le rôle invité pour pouvoir travailler ses autorisations.

Deuxièmement,
Nous avons utilisé le principe des listes noires. Si nous avions utilisez un système de liste blanche, nous aurions du définir l’ensemble des rôles, et l’ensemble des autorisations.
C’est donc en partant du principe que tout le monde a accès à tout, que nous avons fermé les portes aux anonymes.

Explication des fonctions Deny & Allow :
Zend_Acl::deny et Zend_Acl::allow utilisent les mêmes arguments.
Le premier paramètre correspond à un rôle, cela ne change pas des ACL Zend classique.
Le deuxième paramètre correspond à une ressource. Avec Zend AMF, une ressource correspond à un Service.
Le troisième paramètre correspond ici à la fonction d’un service AMF.

Nous avons utiliser null au niveau du deuxième paramètre pour dire : tout les services.

initAcl

Ce dernier paragraphe pour vous parlez de mon opposition face aux spécifications de la documentation Zend_AMF_Server :

If the ACL object is set, and the class being called defines initAcl() method, this method will be called with the ACL object as an argument. The class then can create additional ACL rules and return TRUE, or return FALSE if no access control is required for this class.

En gros, il existe une autre manière de définir les autorisations,
Si vous avez définit un ACL au niveau de votre Serveur AMF. Ce dernier vérifiera l’existence d’une fonction initAcl sur les services lorsqu’ils seront appelés.

Cette fonction est ce que l’on appel un Hook, et vous permets de définir les autorisations et refus au sein de la définition même de vos services.
Autant vous dire que niveau maintenance et centralisation de l’information c’est très moyen..
De plus, si l’on pend l’exemple de ZendAmfServiceBrowser, vous allez devoir modifier la définition de ce service, et cela à chaque fois qu’il y aura une nouvelle version ?

Voici un exemple de fonctionnement

class Service_Book
{
	public function initAcl ($acl)
	{
		$acl->deny('editor', 'Services_Book', 'create');
		$acl->deny('editor', 'Services_Book', 'update');
		$acl->deny('editor', 'Services_Book', 'delete');
		return true;
	}
}

Pour aller plus loin : Vous trouverez un article dédié à l’authentification pour Zend AMF Server avec une base de données : AMF / Zend Authentication using Database

Pour ceux qui ne suivent pas l’actualité, Google tient en ce moment des conférences appelées Google Input/Ouput.

Format vidéo Internet

Pour le premier jour de conférence, nous avons eu droit – entre autre – à l’annonce du format vidéo WebM qui – normalement – devrai devenir le standard vidéo libre du net.
La raison de ce nouveau format, c’est que l’utilisation du H.264 est soumise à une licence payante. A cause de cela Firefox ne pouvait pas lire les vidéos H.264…

Android 2.2

Autre nouveauté, concernant Android.
Nous avons eu la confirmation de la nouvelle version Android 2.2 nommé Froyo, qui apporte son lot d’amélioration :

• Support complet de Flash Player 10.1 et Adobe AIR 2.5
• 2 à 5 fois plus rapide que les anciennes version grâce à un nouveau compilateur Dalvik JIT
• Navigation internet 2 à 3 fois plus rapide grâce à un nouveau moteur Javascript
• Installation des applications sur la carte SD possible en natif
• Mise à jour automatique des applications installées à partir du Market

Pour ceux qui développent pour Android, la version 2.2 du SDK est disponible.

Google TV

Pour le coups, je ne vais pas m’étendre dessus, je préfère rediriger vers de l’information bien plus précise.
Vous pouvez donc aller faire un tour sur le 20minutes : HIGH-TECH – Via Android et un processeur Intel, Google veut marier la télé et le Web. Tout le Web…

Adobe

A cette occasion, Adobe en a profité pour ouvrir l’accès à la Bêta du Player Flash 10.1 pour Android et à la prerelease de Adobe AIR pour Android.

Alors que Adobe AIR peut s’installer sur Android 2.1, FP 10.1 doit être installé sur Android 2.2.
C’est dommage car très – très – peu de gens disposent de la nouvelle version Android Froyo, mais cela annonce aussi que Google ne devrai pas tarder à mettre à jour les terminaux