Zork[Yy]'s log

"meme" du jour : URL-ABC

zorky — Wed, 14 Jul 2010 11:48:00 +0200

Prendre le 1er site que propose le navigateur pour chaque lettre (Chrome chez moi), cela donne ceci :

petites frayeurs pour le S et le P si vous avez des sites pour le X, je reste intéressé bien évidemment.

A qui le tour ?

dokuWiki et intégration : SSO, annuaire, modèles & co

zorky — Tue, 06 Jul 2010 22:45:00 +0200

Préambule

Avant de parler plus spécialement de dokuWiki , un point sur le mot intégration d'applications. Que signifie "intégrer une application ou un progiciel ou un module ou ..." et comment le permet-on ?

On peut avoir plusieurs niveaux d'intégration entre 2 applications (Web j'entends), toutes doivent être, si possible, transparentes pour l'utilisateur :

inclure des données d'une application A dans une application B : l'utilisateur se trouve sur la A, et des informations du site B sont incluses dans le 1er sous diverses formes : flux RSS, widget, OpenSocial, à l'aide d'une API (service Web SOAP, REST, XmlRPC, ...) ou non (fichiers, base de données ou LDAP partagés entre 2 ou N applis) de la part du site B (on peut considérer un flux comme une mini API),
à partir d'une application A, qu'un utilisateur puisse se connecter sur une application B pour y interagir (Google docs, Wiki, enquêtes, etc), avec bien souvent des droits bien particuliers (autorisations),

2 applications seules dans leur coin fonctionnent en général bien, mise à part tout le process de leur mise en place (développement etc), la difficulté devient exponentielle lorsqu'il s'agit d'intégrer de façon transparente pour l'utilisateur une application dans une autre pour y apporter un service supplémentaire.

L'intégration d'une application est souvent rendu possible à l'aide d'API sous forme de services Web (données, annuaire, ...) et aussi également par l'ajout d'un (Web)SSO qui permet à l'utilisateur de passer d'une application vers une application avec son même login et mot de passe et ce, sans se reconnecter s'il l'était déjà, s'authentifier qu'une seule fois est très important afin de faciliter l'usage des outils.

dokuWiki

Wiki

Une petite définition d'un Wiki, selon Wikipédia

Un wiki est un site web dont les pages sont modifiables par tout ou partie des visiteurs du site. Il permet ainsi l'écriture et l'illustration collaboratives de documents.

Wikipédia en est son meilleur représentant, une encyclopédie enrichie par une multitudes de contributeurs. Tous les moteurs de Wiki sont basés à peu près sur le même principe, c'est à dire des balises simples pour formater le texte d'une page (gras, liens, titres, ...), l'écriture de ce billet est effectué de cette façon, à l'aide de balises Wiki, d'autres moteur de blog implémentent Markdown ou Textile qui suivent le même principe .

La collaboration sur un document est effectuée contributeur par contributeur, c'est à dire qu'une page ne peut être éditée à plusieurs (elle sera bloquée si elle est éditée par une personne). Pour ce type de collaboration simultanée, Google docs est plus approprié (que l'on ait un compte google ou non), plus dédié à de court document je pense, à la "Word".

Exemples d'utilisation d'un Wiki :

élaboration d'une documentation sur un projet afin de garder un historique
documentation d'une plateforme
manuels utilisateur ou tutoriels

le choix de dokuWiki

Pourquoi dokuWiki ?

Parmi la pléthore de moteurs qui existent sur le marché OpenSource ou non, dokuWiki est intéressant par sa simplicité (pas de base de données par exemple) et surtout par son architecture qui le rend extensible et modulaire, que cela soit du point de vue de l'authentification, des modèles (de charte graphique), API (XmlRPC et API interne), avec bien entendu bon nombre de plugins proposés (> 600) (cf. les fonctionnalités), sans compter une architecture de développement de plugins bien pensée (évènements et hooks utilisées dans les actions).

L'un des points négatifs de mon point de vue étant qu'il soit développé en PHP mais on s'y remet vite aux $, mais aussi, des releases officielles peu fréquentes, malgré un trunk assez actif.

Principes d'authentification

dokuWiki propose un système d'authentification extensible, qui peut être étendu à d'autres protocoles d'authent (LDAP, CAS, Shibboleth, OpenID, NTLM, AD, spécifique, etc). Par défaut, dokuWiki gère les logins et mots de passe sous forme de fichier texte (le mode plain).

Il suffit de dériver de la classe auth_basic (l'interface/classe abstraite qui représente le contrat d'authent), d'implémenter les méthodes obligatoires et certaines optionnelles, et ensuite de préciser la stratégie utilisée pour l'authentification (la nouvelle classe dérivée d'auth_basic) dans le fichier de configuration (l'entrée $conf['authtype'] = 'maclasse') : dokuWiki se chargera d'instancier cette dernière et d'appeler les méthodes voulues qui sont précisées dans la classe dérivée, à l'aide du tableau cando définit dans la classe de base auth_basic.

Par exemple addUser à true provoquera l'appel de la méthode createUser($user,$pwd,$name,$mail,$grps=null) qui devra être implémentée.

Souvent, les méthodes utilisées permettent de se brancher sur une base de comptes existantes (bdd, LDAP, ...qu'on appellera référentielle) pour les besoins d'authent et d'annuaire (login mais aussi nom, prénom, email, ...), afin de lire le compte et/ou ses groupes d'accès ou bien de le modifier, la page authentication_backend précise les méthodes à utiliser le cas échéant.

Dans ce cas, nous avons bien de la fédération d'identités (en gros 1 login partagé par plusieurs applications, un référentiel hébergé ou réparti sur un ou plusieurs points) mais la bannière de login pourra être dupliquée sur l'application A, dokuWiki, etc, on ne répond pas dans ce cas au besoin de SSO : 1 login et ne pas se réauthentifier sur dokuWiki si on l'était déjà sur l'application A.

dokuWiki propose la méthode trustExternal qui surpasse toutes les autres (elles seront alors ignorées à quelques exceptions près), elle nous permettra d'implémenter le SSO. Son activation s'effectue via le tableau cando avec la clé external qu'on mettra à true dans le constructeur de la classe dérivée.

$this->cando['external'] = true;

Le SSO, comment ?

On peut voir au moins 2 manières d'implémenter du SSO, ou plus précisemment détecter une authentification existante sur un site tiers :

par l'usage d'un cookie de domaine, qui contiendra un jeton : nous dira si l'internaute est déjà passé par une application et qu'il s'est donc déjà authentifié : si non, soit une redirection s'effectuera afin de le rediriger vers un point central d'authent, soit sur l'application cliente elle-même. Cette solution est adapté aux applications qui se basent sur un même domaine, évite un aller-retour lors de l'arrivée de l'internaute (s'il était déjà connecté sur une application partenaire), le jeton contenu dans le cookie est bien évidemment à vérifier afin d'éviter toute faille de sécurité. S'il n'existe pas de cookie avec le jeton, il est redirigé vers l'application qui centralise l'authentification, se connecte, le cookie est fixé avec le jeton, puis il est redirigé vers l'application appelante dokuWiki.

Cela est schématisé par l'image suivante, si l'internaute était arrivé par l'application A, le cookie de domaine serait déjà garni lors de l'arrivée sur dokuWiki, cela réduit d'un aller-retour systématique, ce qui n'est pas le cas dans la solution par session ci-après

En revanche, une très grosse contrainte technique des navigateurs sur HTTP peut rendre difficile son utilisation, comme le précise le RFC 2109, section 4.3.2 Rejecting Cookies

A Set-Cookie from request-host y.x.foo.com for Domain=.foo.com would be rejected, because H is y.x and contains a dot

autrement dit, cela interdit les sous-domaines qui contiendraient un . (point ou dot), d'aller plus loin de 2 niveaux que domain.ntld. Par exemple www.info.domain.ntld et www.finance.domain.ntld ne pourront pas partager le même cookie de domaine (qui serait fixé sur domain.ntld), alors que pour docs.google.com et calendar.google.com cela est rendu possible. Cette contrainte devrait être levée dans les futures versions des navigateurs, en attendant, il faudra trouver une autre solution.

en jouant sur l'ouverture de session, puis ensuite par un jeu de redirection : la 1ère fois que l'internaute arrive sur dokuWiki, à l'ouverture de session, il est instantanément redirigé vers la plateforme/application qui centralise l'authentification (application A), vers une page spéciale qui gèrera ensuite le retour vers dokuWiki : si l'internaute était connecté sur application A alors il est immédiatement redirigé vers dokuWiki, sinon il se connecte puis est redirigé vers dokuWiki. L'URL de retour contient notamment en paramètre un jeton de type HMAC , avec une clé secrète partagée entre l'application qui gère le login et dokuWiki afin de s'assurer de qui envoie les informations vers le Wiki lors de l'authentification, notamment la clé utilisateur (id, email, ...). Ce type de challenge est assez courant, on retrouve ce principe de redirections sur OpenID ou OAuth.

le principe :

Même si elle impose automatiquement une redirection, la 2è solution est moins contraignante, nous choisirons donc cette dernière pour dokuWiki.

Dans les 2 cas, le principe se base sur de la redirection HTTP qui joue un challenge entre le site client et le site qui permet de s'authentifier. L'URL de retour vers le Wiki contient le jeton HMAC, ainsi qu'une clé identifiant l'utilisateur qui s'est authentifié, clé qui pourra être utilisé dans un service d'annuaire pour en connaitre plus sur lui (nom, prénom, email). On pourra ajouter également la date/heure de connexion de l'utilisateur afin de limiter l'usage du lien / jeton dans le temps.

Concernant les groupes d'accès, dokuWiki stocke le(s) groupe(s) dans un fichier texte ~dokuwiki/conf/acl.auth.php, la clé de configuration ACL doit être activée $conf['useacl']=1; . On pourra s'aider d'un service d'habilitations, inclus ou non dans le service d'annuaire, afin de déterminer à quels groupes appartient l'utilisateur qui arrive sur le Wiki.

un exemple de groupes d'accès, déclinés selon les droits dokuWiki :

*       @ALL    0
*       @rpc    4
*       @geeks  16
*       @geeks%2dro     1

Le groupe geeks a tous les droits d'édition sur les pages, ainsi que sur les fichiers, pour une population de contributeurs. Le groupe rpc pourrait être affecté lors de l'accès à l'API (XmlRPC ou la syndication) par un système tiers, avec des droits moins forts (pas de suppression par exemple). Le groupe geeks-ro (les caractères du type - doivent être fournis en code hexa) pourrait être réservé pour des utilisateurs qui n'ont droit qu'à une consultation seule (et non à l'édition). Tout le reste (@ALL) aucun droit.

exemples de code

On aura besoin : de la classe dérivée, de son constructeur, et de la méthode trustExternal qui contiendra l'initialisation de l'utilisateur et groupes appartenant à dokuWiki. Hormis l'authentification et l'affectation des groupes, l'authent est souvent couplé à un service d'annuaire, afin de connaitre a minima l'email, le nom, prénom et civilité du connecté. A défaut de service d'annuaire (SOAP, REST), ces derniers pourraient être renvoyés en même temps que l'URL de retour, en tant que paramètres.

Ce ne sont que des bouts de code pour démontrer le principe en 3 étapes, le principal étant dans trustExternal

Les parties dont on a besoin :

la classé dérivée que nous nommerons auth_provider, hérite de auth_basic, dokuWiki sait quel provider instancier par la clé de configuration $conf['authtype']='provider', la classe sera contenue dans le fichier ~dokuwiki/inc/auth/provider.class.php

class auth_provider extends auth_basic
{
  ...
}

son constructeur

function auth_provider() {
      $this->cando['external'] = true; // on utilise le mode external pour l'authent, seule trustExternal sera appelée de façon implicite
      $this->cando['logoff'] = true; // pour usage manuel, vidage cookie et session, permet d'ajouter à une page ?do=logout pour un logoff
 
      $this->success = true;
      return;
    }

et la méthode trustExternal pour l'initialisation de l'utilisateur dokuWiki avec ses groupes si le challenge SSO a réussi

function trustExternal($user,$pass,$sticky=false)
 {     
      // session déjà ouverte ? on initialise l'utilisateur dokuWiki
      if(isset($_SESSION[DOKU_COOKIE]['auth']['buid']))       
      {
            $this->_setUser($_SESSION[DOKU_COOKIE]['auth']['buid']);
      } else { // retour de la redirection de l'appli de login ?
                        if($_GET["token"]!=null)
            {
              // vérif signature / clé
              if($this->_verifSignature($_GET["token"]) && isset($_GET['ui'])))
              {                                       
                  // appel à un service d'annuaire pour l'obtention des infos utilisateurs
                  $response = $this->annuaireGetUser($_GET['ui']);
                  if($response)
                   {
                     // init utilisateur dokuWiki
                                       $this->_setUser($response->user);
                  }
              }
                        // non alors redirection vers l'app login              
            } else {                           
                              header("Location: http://".APPLICATION_A."/logon/?return_url=".rawurlencode("http://".SERVEUR_WIKI.$_SERVER['REQUEST_URI']));
                        }
 
      }
 
      $this->success = false;
      return false;   
 }
 
  // initialise l'utilisateur dokuWiki
  function _setUser($user)
  {             
         global $USERINFO; // l'utilisateur dokuWiki
     $grps = array();   // groupe(s) de l'utilisateur
 
          // profil utilisateur dokuWiki         
     $USERINFO['name'] = $user->Nom;
     $USERINFO['mail'] = $user->Email;     
     array_unshift($grps,$user->groupe);         
     $USERINFO['grps'] = $grps;
 
          // obligatoire
     $_SERVER['REMOTE_USER'] = $user->Email;
 
     // session de cache dokuWiki     
     $_SESSION[DOKU_COOKIE]['auth']['user'] = $user->Nom;
     $_SESSION[DOKU_COOKIE]['auth']['info'] = $USERINFO;
     $_SESSION[DOKU_COOKIE]['auth']['time'] = time();
  }

et voilà !

Le SSO est une réelle valeur ajoutée pour l'utilisateur, quoi de plus désarmant que de devoir se connecter plusieurs fois, voire, avec un compte différent. Dans un autre contexte, OpenID, permet également de fédérer son identité / authentification, afin de ne pas recréer pour une ième fois un login et mot de passe.

Modèles, plugins

dokuWiki, dans sa conception permet d'étendre et de développer son propre modèle de charte. Le mieux étant de partir d'un template existant et de le modifier. Le modèle est stocké sur ~dokuwiki/lib/tpl/<template>.

Egalement, le nombre de plugins proposé est assez conséquent, 650 ! bien entendu, on veillera à ce que le plugin soit maintenu, que ce dernier ait des contributeurs actifs. Les plugins seront à installer dans le répertoire ~dokuwiki/lib/plugins/<plugin>. Chaque plugin est désactivable par la simple création d'un fichier vide disabled. Pour l'authentification, il nous faudra au moins le plugin acl. Parmi les intéressants, on notera tag qui permet de marquer une page par des tags et de retrouver toutes les pages relatives à un tag, mais aussi note ou odt, il reste le plugin PDF à tester.

ReMIX 2010

zorky — Fri, 28 May 2010 13:57:00 +0200

J'ai assisté jeudi à une partie de l'après-midi au ReMIX 2010 dans les locaux de Microsoft à Issy-les-Moulineaux.

Le ReMIX c'est l'évènement à mi-chemin entre le développement et le design/communication/marketting ou comment concilier les 2 mondes : geek et design/comm, ce type d'évènement s'adresse d'ailleurs un peu plus aux Web Agency, suffit de voir la page d'accueil du site dédié ;).

Après avoir pris mon cube multi-couleurs ReMIX, et m'être assis à côté d'un designer ayant un très beau iPad, la keynote pouvait commencer, quelques notes de l'après-midi.

Keynote présentée par Eric Rudder, Américain. Après une introduction en français, le reste était en anglais, très compréhensible et accessible, il parlait distinctement et "lentement", je le remercie pour ça.

La keynote était agrémentée de démos sur divers sujets (les intervenants : Guillaume Roques, David Rousset) :

vidéo ou RIA avec Silverlight, en Smooth Streaming, avec Roland Garros ou France 24, le tout en HD. Ce dernier restranscrit à la volée la parole en écrit avec une indexation en temps réel, assez bluffé par ça. Ce que j'ai toujours aimé c'est la possibilité de retourner en arrière, ou pour le tennis de revoir les vidéos au ralenti. Exemples avec MSN sur l'expo Van Gogh et Monet et les possibilités du DeepZoom, la société Images, ou enfin, Bing et l'intégration SL, direction le 1er Starbuck à Seatle, toujours aussi bon avec le DeepZoom et la superposition des photos (appuyer sur le personnage bleu en bas de page).
IE9 avec le site dédié Test drive qui donne des démos assez intéressantes pour démontrer l'efficacité de la future version d'Internet Explorer 9 : utilisation du GPU de la carte graphique et exploitation du multi-coeurs, très en phase avec le matériel actuel, ou encore implémentation de SVG 1.1, HTML 5 & CSS 3, Javascript compilé
Smart Software avec la plateforme XNA pour les jeux : 1 plateforme pour n devices (Windows Phone, XBox, Windows 7)
programme MS WebsiteSpark

Les différentes sessions qui ont suivi :

IE9 avec David Rousset : avec IE 8 il existait 7 200 tests unitaires pour CSS 2.1/HTML 4.01, ont été fournis au W3C dont MS participe au working group HTML5 (Paul Cotton), il est prévu plus de 60 000 tests unitaires pour HTML 5 / CSS 3 afin aussi de clarifier les spécifications (afin que tous les navigateurs rendent exactement la même chose). Démos des Border queries, qui permettent d'adapter l'affichage selon le périphérique qui se connecte (PC, Mobile, ...). Un effort a été porté pour améliorer les performances Javascript : ce denier est compilé à la volée en code natif. IE 9 obtient de bons résultats aux tests Sun Spider face aux autres moteurs Javascript.

plateforme Web MS avec Pierre Lagarde : démo de WPI afin d'installer simplement et rapidement des extensions ou frameworks/moteurs (blogs, CMS, ...) supplémentaires sur IIS. Démos Silverlight avec quelques sites (DIA rubrique découvrir. Quelques intervenants de startup sur des projets en collaboration avec Microsoft : lachainetechno.com, une WebTV qui a développé (avec la collaboration d'Adenova) une extension (SVP) Wordpress afin d'inclure des vidéos Silverlight sur un blog / CMS. Ce qui est fort, c'est la démonstration de la lecture d'une vidéo Smooth Streaming sous..iPhone ou iPad...la vidéo est retranscrit (par IIS MediaServer) en temps réel pour le format des devices (certainement Quicktime, en version Beta), un beau pied de nez aux vidéos Flash

Azure : NB : l'offre MSDN Premium offre quelques heures Azure, c'est toujours bon à prendre. Invité : Kobojo qui ont développé une application Facebook (RobotzArena), un remake de baston entre 2 personnages que l'on peut s'amuser à améliorer (costumes, armures, ...). Une partie (frontaux + cache) est hébergée sur Azure, en revanche la partie Data (SQL Server) à l'extérieur : intéressant, une application Azure peut se connecter sur un SGBD non azure. Présentation également d'une version Memcached pour Azure avec un dashboard, téléchargeable sur CodePlex Cloudcache. Pour rappel, Memcached est un cache partagé.

WCF avec le projet SOKOZ, site de ventes événementielles. Ils ont utilisé Azure Service Bus avec Azure Ready afin de répondre beaucoup plus rapidement aux requêtes.

Assez content de l'après-midi, malgré parfois des tendances marketting un peu trop poussées, je suis reparti avec mon cube qui fera plaisir à ma fille, et mon tshirt.

Nouveau blog et les actions à entreprendre pour sa mise en ligne

zorky — Tue, 25 May 2010 21:40:00 +0200

J'ai ouvert un nouveau blog pour toucher au thème de la photo. Je pratique depuis quelques temps déjà, et je pense qu'un espace dédié était le bienvenu. Quelques points à aborder avant l'ouverture d'un nouveau blog,

La fameuse liste :

choisir un moteur de blog : j'ai choisi de m'orienter vers le fameux Wordpress, j'aurais ainsi testé au moins 3 moteurs : typosphere, dotclear (pour ce présent blog, dotclear semble stagner depuis pas mal de temps), wordpress parce que je n'ai aucune personnalité et veux faire comme tout le monde. Wordpress a une bonne réputation alors pourquoi pas,
où vais-je l'héberger ? sur mon NAS Synology bien sûr !
se prendre un thème : Mystique de Digital Nature m'a bien emballé et semble être maintenu - ce côté blanc sur fond noir, un juste équilibre. Après avoir recherché par l'interface Wordpress, l'installation s'effectue toute seule, une pure merveille. Le thème a son interface d'administration spécifique pour son paramétrage (détail de design, flux Feedburner, twitter),
le domaine Internet ? sharpness me semblait approprié pour le sujet abordé : la netteté ou le "piqué" est un point important et récurrent en photographie. Dans le choix d'un objectif, le piqué apparait dans les 1er critères, piqué qui se paye cher souvent,
quelques widgets : un blog qui parle photo doit avoir quelques composants pour afficher des photos : de Flickr, sur les billets. Egalement, un blogroll sur le thème me parait primordial, ou sur mon écosystème (Twitter, Flickr, ...). La recherche et l'installation par le backoffice Wordpress est vraiment une réussite, on recherche, on sélectionne, on installe,
ajout d'outils de statistiques : rajout du blog dans Google analytics et activation de l'extension ad-hoc ainsi que pour Piwik qui gère le multi-sites. Pour ce dernier, bien qu'il y ait une extension Piwik, il y a conflit entre les deux. J'ai dû mettre à jour le pied de page (Apparence / Editeur / Pied de page (footer.php)) pour rajouter le code Javascript Piwik juste avant la balide <body>,
pour le format des URLs des billets, j'ai choisi de ne pas mettre la date mais uniquement le titre, parait que c'est mieux,
ajout dans Google webmaster tools du nouveau blog et génération du sitemap grâce à l'extension prévue pour ça,
un antispam peut être utile,
écrire un A propos, un 1er billet, secouer et livrer

Sharpness est né.

On verra dans 6 mois pour ajouter quelques widgets du type : nuage de tags, archives, ...

NHibernate et les propriétés magiques

zorky — Sun, 14 Mar 2010 13:05:00 +0100

Préambule

La différence entre la théorie et la pratique ? en théorie, il n'y en a pas, en pratique, si.

Le monde du développement est loin d'être un monde idéal, dans la réalité, nous rencontrons souvent des situations particulières auxquelles il faut faire face. Un framework, en plus de répondre aux besoins les plus généraux, se doit également de fournir des solutions de contournements, des "astuces de programmation" diront certains.

Dans ce court billet, nous allons parler de 2 fonctionnalités de NHibernate sur les propriétés lorsque notre modèle ou le contexte ne répond pas exactement à l'idéal que l'on devrait avoir en termes d'architecture.

Imaginons que l'on ait une entité Individu, que l'on affichera sur une page, sous forme d'une liste d'individus. Dans notre modèle nous avons la relation simple suivante entre un individu et son appartenance à un établissement :

La liste paginée est triable (cf. ce billet pour la pagination et le tri en NHibernate) par le nom, prénom, le nom de l'établissement. On pourrait facilement créer des entités Individu et Etablissement avec cette relation, mais l'on ne souhaite pas le faire, car nous avons uniquement besoin du nom de l'établissement pour le tri, sans vouloir représenter tout le modèle derrière Etablissement. Le tri et la pagination ne peuvent s'effectuer que par l'intermédiaire de NHibernate, nous avons donc besoin d'une proprété mappée dans une classe pour que l'ORM puisse l'atteindre et actionner le tri.

Formula

les formula permettent ce genre d'astuces de programmation : avoir une propriété EtabNom qui pointe vers une table externe (et non vers une classe comme on le ferait habituellement avec du many-to-one) mais sous forme d'une requête SQL, la propriété se tranforme alors en :

<property 
  name="EtabNom"
  formula="(select etab.NOMALPHA from ETABLISSEMENT etab where etab.ID=ETAB_ID)">
</property>

ce qui donne pour l'entité Individu, où ETAB_ID est un champ de la table INDIVIDU mappée :

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" auto-import="true" >
  <class name="MyNamespace.Individu, MyAssembly" table="INDIVIDU">
    <id name="ID" column="ID" type="System.Int32" access="property">
      <generator class="identity"></generator>
    </id>
    <property name="Nom" column="nom" not-null="true" type="System.String" access="property"/>
    <property name="Prenom" column="prenom" not-null="true" type="System.String" access="property"/>
    <property name="Email" column="email" not-null="true" type="System.String" access="property"/>
    <property name="EtabNom"
              formula="(select etab.NOMALPHA from ETABLISSEMENT etab where etab.ID=ETAB_ID)"></property>
  </class>
</hibernate-mapping>

on pourra alors trier sur la propriété individu.EtabNom sans utiliser d'entité Etablissement. Une requête Linq NHibernate du type

lasession.Linq<Individu>().OrderBy(ind => ind.EtabNom).Take(20);

se traduira en SQL de la façon suivante, on retrouve le morceau SQL de l'attribut formula :

SELECT   top 20 individu2_.ID            AS IND1_3_0_,
                individu2_.nom           AS ind4_3_0_,
                individu2_.prenom        AS ind5_3_0_,
                individu2_.email         AS ind7_3_0_,
                individu2_.etab_id       AS etab12_3_0_,
                (SELECT etab.NOMALPHA
                 FROM   ETABLISSEMENT etab
                 WHERE  etab.ID = individu2_.ETAB_ID) AS formula0_0_
FROM    INDIVIDU individu2_
ORDER BY (SELECT etab.NOMALPHA
          FROM   ETABLISSEMENT etab
          WHERE  etab.ID = individu2_.ETAB_ID) ASC

ce type de propriété peut être également utile en tant que champ calculé, un count sur un champ d'une table externe sans pour autant avoir une collection mappée. Bien entendu, les formula sont à utiliser avec parcimonie, étant donné que c'est du pur SQL, à utiliser sur des tables de références.

Noop

A l'inverse, on pourrait avoir une classe Etablissement qui ne contiendrait pas de propriété Individus (dans le sens POCO donc non mappée) mais qui serait utile d'avoir pour effectuer des sélections : donne-moi les établissements qui ont plus de 200 individus intérimaires. Au niveau de la collection, cela rejoint ce billet qui parlait de ce type de set.

Le type d'accès noop (ou none) sur une propriété permet cela : pouvoir effectuer une requête sur une propriété non mappé dans une classe.

Par exemple, dans le .hbm, on pourrait avoir une collection one-to-many qui nous donne les intérimaires d'un établissement, les individus intérimaires seraient de type 3, une collection qui se traduit par :

<bag  name="Interim" access="noop"
           where="(typind = 3)">
     <key column ="ETAB_ID"/>
     <one-to-many class="MyNamespace.Individu, MyAssembly"/>
 </bag>

dans la classe Etablissement, la propriété Interim n'existe pas.

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" auto-import="true" >
  <class name="MyNamespace.Etablissement, MyAssembly" table="ETABLISSEMENT">
    <id name="ID" column="ID" type="System.Int32" access="property">
      <generator class="identity"></generator>
    </id>
    <property name="EtabNom" column="NOMALPHA" not-null="true" type="System.String" access="property"/>
    <bag name="Interim"
         where="(typind = 3)"
         access="noop">
      <key column ="ETAB_ID"/>
      <one-to-many class="MyNamespace.Individu, MyAssembly"/>
    </bag>
  </class>
</hibernate-mapping>

cela permet ensuite d'effectuer des requêtes HQL, les établissements ayant plus de 200 intérimaires :

var etabs = session.CreateQuery("
  from Etablissement etab  
  where size(etab.Interim) > 200").List<Etablissement>();

qui se traduit en la requête SQL :

SELECT etablissem0_.ID       AS ETABCONS1_4_,
          etablissem0_.NOMALPHA AS ETABCONS2_4_
   FROM   ETABLISSEMENT etablissem0_
   WHERE  (SELECT count(interim1_.ETAB_ID)
           FROM INDIVIDU interim1_
           WHERE etablissem0_.ID = interim1_.ETAB_ID
           AND ((interim1_.typind = 3))) > 200

de façon identique, à utiliser avec prudence, sous peine de rompre l'abstraction que nous avons avec le SQL.

WCF, REST, XML, JSON-P et accessoirement jQuery

zorky — Wed, 10 Mar 2010 23:35:00 +0100

Préambule

Imaginons que l'on veuille développer un service web d'interrogation basé sur REST, c'est à dire qui s'appuie sur HTTP uniquement pour les requêtes et les (codes : 200, 400, 404, 403, ...) réponses. Les réponses peuvent être au format Xml ou JSON. Ce service reste simple : une entrée du type int, et un retour d'un type primitif : string, ou un tableau de string : pour un n° de responsable, avoir les n° associations qu'il gère.

côté client : JSON et JSON-P

Le retour au format JSON est souvent pris pour un usage côté client / navigateur, par exemple à des fins de création de widgets à l'aide d'APIs, plus particuliérement pour un traitement javascript (facilité par ce format natif javascript) dans un mode Ajax. Comme chacun le sait ou a été déjà confronté, les appels Ajax ne peuvent être cross-domain, c'est à dire qu'un appel d'un script hébergé et à partir du domaine dummy.com vers domain.ntld est interdit par le navigateur (par l'objet XMLHttpRequest).

Les méthodes les plus connues pour palier à cette restriction sont :

soit développer un proxy côté serveur dummy.com qui effectura ensuite la requête vers le domaine distant domain.ntld pour renvoyer ensuite le résultat au script appelant,
soit se baser sur une fonction de callback JSON-P (JSON with Padding), technique qu'offre bon nombre d'APIs de nos réseaux sociaux préférés (Flickr, Delicious, ...) : il s'agit de mettre en place une URL dans une balise <script> créée dynamiquement, où le contenu de retour au format JSON sera encapsulé dans une fonction javascript (le callback), exécutée lors du retour de l'appel.

le résultat ressemblera à quelque chose du type :

<script type="text/javascript" script="http://domain.ntld/api/resp/2?callback=myfct">
  myfct({dataJSON});
</script>

par exemple, pour un appel Flickr, sur un bouton, la balise <script> avec l'URL d'interrogation sera créée dynamiquement, la fonction callbackFctFlickr avec les données au format JSON sera appelée au retour de l'appel :

$j('#btnSearch').click(function() {
            createScriptJSONP();
        });
 
        function createScriptJSONP() {
        $j('#results').empty();
        var urljsonp = $j('#sApi :selected').val();
        var api = $j('#sApi :selected').text();
 
        var s = document.createElement('script');
        if (api == "Delicious") {
            s.src = urljsonp + $j('#txtSearch').val() + '?callback=callbackFctDelicious';
        } else {
            s.src = urljsonp + $j('#txtSearch').val();
        }
        s.type = 'text/javascript';
        document.body.appendChild(s);
    } // création manuelle du script pour l'appel API
 
    function callbackFctFlickr(data) {                
        $j('#results').append('<ul>');
        $j(data.items).each(function(i, v) {            
            $j('#results').append("<li id=" + i + "><a href='" + v.link + "'>" + v.title + "</a><br/></li>");
            $j("<img/>").attr("src", v.media.m).appendTo("#" + i);            
        });
        $j('#results').append('</ul>');
    }

Amusons-nous avec 3 APIs : Flickr, Yahoo, Delicious , à tester sur la page démo en sélectionnant l'API souhaitée (essayer amélia (c'est ma fille) ou architecture pour Flickr, photography pour Delicious, les deux pointent vers mes comptes),

Une alternative avec jQuery, où la création dynamique du code <script> s'effectue automatiquement, ainsi que l'ajout de la fonction callback, grâce à la fonction getJSON() ou ajax(), cette dernière offre plus d'options, et donc, de souplesse.

$j('#btnSearch').click(function() {
            createScriptJSONP();
        });
 
   function createScriptJSONP() {
        $j('#results').empty();
        var urljsonp = $j('#sApi :selected').val();
        var api = $j('#sApi :selected').text();
        var url = urljsonp + $j('#txtSearch').val();
 
        $j.ajax({
            url: url,
            dataType: 'jsonp',
            jsonp: api=='Flickr'?'jscallback': 'callback',
            success: function(data) {
                switch (api) {
                    case 'Flickr':
                        callbackFctFlickr(data);
                        break;
                    case 'Yahoo':
                        callbackFctYahoo(data);
                        break;
                    case 'Delicious':
                        callbackFctDelicious(data);
                        break;
                }
            }
        });

exemples d'appels générés sur Flickr, Yahoo ou Delicious avec jQuery, la fonction précisée en paramètre à jsoncallback ou callback est ajoutée par jQuery

http://api.flickr.com/services/feeds/photos_public.gne?id=55936300@N00&tagmode=any&format=json&tags=am%C3%A9lia&jsoncallback=jsonp1268130184172&_=1268130185391

http://search.yahooapis.com/ImageSearchService/V1/imageSearch?appid=YahooDemo&output=json&query=am%C3%A9lia&callback=jsonp1268130547073&_=1268130655088

http://feeds.delicious.com/v2/json/zorky/photography?callback=jsonp1268130547074&_=1268130676051

Bien entendu, cette technique fonctionne si le serveur distant encapsulte le JSON (qui doit être bien formé) dans une fonction javascript, à la JSON-P.

côté serveur

En .NET, WCF permet nativement de renvoyer au choix, des données au format XML (POX, Plain Old XML, par défaut) ou au format JSON, voire en binaire, pour des images par exemple, mais point d'encapsulation JSON-P (qu'on se rassure, cela arrive avec la version WCF de .NET 4.0, avec le binding webHttpBindingWithJsonP).

En attendant, en cherchant sur Goooooogle, on tombe facilement sur JSON with Padding (AJAX) qui permet d'étendre WCF pour ajouter une fonction callback à un appel JSON qui le demande.

Au lieu de recevoir les données au format JSON, par exemple

{"mylistJSONResult":["56056","56080","56129","56134","56227","56257"]}

on aura les données JSON encapsulées dans une fonction, avec un appel du type ?callback=myfct :

myfct( {"mylistJSONResult":["56056","56080","56129","56134","56227","56257"]} );

afin d'utiliser ce hook, dans le contrat WCF, on aura un attribut JSONPBehaviour qui nous permettra de préciser la fonction de callback :

[OperationContract]
        [WebCache(CacheProfileName = "cachingrest")]
        [WebGet(UriTemplate = "assoc/resp/{respid}.json",
            ResponseFormat = WebMessageFormat.Json,
            BodyStyle = WebMessageBodyStyle.Wrapped)]
        [JSONPBehavior(callback = "callback")]
        List<string> mylistJSON(string respid);

l'attribut [WebCache] est tiré du WCF Rest Starter Kit qui permet de cacher (entêtes cache-control / expires) les requêtes GET de ce type. Rappelons que c'est l'un des grands avantages des requêtes GET par rapport aux POST : la capacité d'utiliser le cache navigateur.

l'attribut [WebGet] précise le motif de la requête REST, en GET, ainsi que le format de données retourné, ici JSON en mode wrappé (c'est à dire de la forme "mylistJSONResult" : [data]): on aura une URI du type http://domain.tld/mysvc.svc/json/assoc/resp/45.json?callback=myfct

Malheureusement, le code JSONPBehavior fonctionnera sur tout le service, que cela soit pour du JSON ou du ...XML.

Comme on veut servir du JSON-P ET du XML, on devra avoir 2 méthodes dans le contrat (et dans son implémentation donc), et un discriminant dans la configuration Web.config, pour déclencher le hook sur l'appel opportun. Pour bien faire, il s'agirait de modifier le module afin qu'il ne traite pas (ie : ajout de l'encapsulation JSON dans une fonction) les données lorsqu'il s'agit d'un format XML, je n'ai pas emprunté ce chemin.

le contrat de nos 2 méthodes, 1 pour le XML, 1 pour le JSON-P, qui répondent selon le motif URL :

/// retour XML
        /// URL au format http://localhost/mysvc.svc/xml/assoc/resp/{id}
        [OperationContract]
        [WebCache(CacheProfileName = "cachingrest")]
        [WebGet(UriTemplate = "assoc/resp/{respid}")]
        List<string> mylist(string respid);
 
        /// retour JSON encapsulé
        /// URL au format JSON pur http://localhost/mysvc.svc/json/assoc/resp/{id}.json
        /// ou JSON-P http://localhost/mysvc.svc/json/assoc/resp/{id}.json?callback=myfct
        [OperationContract]
        [WebCache(CacheProfileName = "cachingrest")]
        [WebGet(UriTemplate = "assoc/resp/{respid}.json",
            ResponseFormat = WebMessageFormat.Json,
            BodyStyle = WebMessageBodyStyle.Wrapped)]
        [JSONPBehavior(callback = "callback")]
        List<string> mylistJSON(string respid);

et le web.config, où le descrimant s'effectue grace à l'attribut address :

<system.serviceModel>  
    <serviceHostingEnvironment aspNetCompatibilityEnabled="true" />    
    <services>
     <service name="ws.rest.Assoc">
      <!-- cas JSON : extension JSONP -->
        <endpoint address="json"
          behaviorConfiguration="ws.rest.AssocRest"
          binding="customBinding"
          bindingConfiguration="jsonpBinding"
          contract="ws.rest.IAssoc" />
      <!-- cas XML -->
        <endpoint address="xml"
          behaviorConfiguration="ws.rest.AssocRest"
          binding="webHttpBinding"
          contract="ws.rest.IAssoc" />
      </service>
    </services>    
   <behaviors>   
    <endpointBehaviors>
          <behavior name="ws.rest.AssocRest">
             <webHttp />
          </behavior>
    </endpointBehaviors>
   </behaviors>
   <bindings>      
      <customBinding>        
        <binding name="jsonpBinding">
          <jsonpMessageEncoding/>
          <httpTransport manualAddressing="true"/>
        </binding>
      </customBinding>
   </bindings>
   <extensions>
      <bindingElementExtensions>
        <add name="jsonpMessageEncoding"
          type="ws.rest.JsonpBindingExtension, ws"/>
      </bindingElementExtensions>
   </extensions>
</system.serviceModel>

pas forcément la solution la plus élégante, nous sommes bien d'accord, .NET 4 apportera très certainement une réponse plus propre à ce type de problématique.

La prochaine fois, nous verrons la truite saumonée en papillote.

Techdays 2010, jour 3

zorky — Thu, 11 Feb 2010 10:07:00 +0100

Ce 3è jour sera beaucoup consacré à l'ergonomie et au design. Ce n'est pas ma compétence première, cela sera donc très difficile pour moi de résumer correctement les 3 sessions auxquelles j'ai assisté - malgré leur richesse - autrement que par des mots clés et de façon très lapidaire.

Ergonomie Web

La session la plus intéressante de la journée, présentée par une experte en la matière : Amélie BOUCHER. Cela donne envie de lire son ouvrage sur le sujet.

L'ergonomie Web se résume en 2 notions, ou 2 mots ayant des objectifs bien différents : utilité et utilisabilité

Utilité = répondre à besoin (fonctionnel) tandis que

Utilisabilité (usability en anglais) = répondre à une simplicité d'utilisation, elle est définie par la norme ISO 9241

il faut chercher un équilibre entre ces 2 notions.

Utilité

Travailler sur ce point permet de bien choisir les fonctions d'un système, ni trop peu, ni trop, cela dépend du contexte d'utilisation, et du type d'applications (métier, web, ...). Dans tous les cas, pour cela, il est nécessaire de connaitre les besoins des utilisateurs, et son contexte, aussi, il ne faut : ni les surestimer, ni les sousestimer, mais les estimer au mieux. (cf. méthode des personas + scénarios utilisateurs).

Utilisabilité

Techniques : SUPPRIMER la fonction (fonction réelle identifiée ou latente ?), HIEARCHISER : lesquelles (fonctions) sont primordiales, secondaires : fréquence, efficacité, efficience ("j'attends mon but au moindre coût"), satisfaction

Réalité d'une interface "ergonomique" : elle doit être invisible

Tests utilisateurs

Suivent quelques exemples avec Google, Live search, Amazon, où il est démontré qu'un temps de chargement plus élevé de la page (de 0,4 s à 0,9 s par ex) fait perdre des ventes ou des clics publicitaires (de l'ordre de -2 à 20 % selon). Une démo sur un webmail où il est demandé au panel utilisateurs d'envoyer un message : la plupart ne voient pas le gros bouton "Envoyer un message" (matériel : Tobii T120 eye-tracking).

Un autre moyen de tester : tests comportementaux, sur un site, une partie des internautes est redirigée vers d'autres versions d'une page, ceci afin d'observer le comportement et s'il se traduit par un gain (de ventes, ...).

Conclusion

Très bonne session sur un sujet très délicat et récurrent à résoudre : l'ergonomie au sens large d'une application Web.

Eléments de design visuel : formes, couleurs et typos

Globalement intéressante pour sa culture générale, courte session (35 mn hors questions) présentée par Marc-André FRANCART (ou http://www.r-u-experienced.net). Pas de résumé pour celle-ci, juste 2-3 phrases.

Une citation :

"Ce qui est inutile est laid, ce qui est laid est repoussant, ce qui est repoussant vend mal" (Raymon Loewy)

Le design pour l'expérience utilisateur (UX) se décline selon un triangle en 3 parties : techno (base), fonctionnalités (milieu), UX (haut.

Conclusion : 35 % des utilisateurs achétent uniquement sur le visuel.

Objets intelligents, objets vivants

Dernière session sur le sujet du Design, présentée par Dominique SCIAMMA du Strate Collège Designers, école réputée en design. Session intéressante et bien amenée par l'orateur mais difficilement résumable.

On parlera de RFID, Nanotechnologies, IPv6 (!), du retour de l'IA, et des défis qu'induisent certains projets design dans la vie courante, au niveau éthique, politique et philosophique.

Le strate Collège a un canal sur Youtube où ils présentent leurs intéressants projets en design, à voir.

Techdays 2010, jour 2

zorky — Wed, 10 Feb 2010 17:33:00 +0100

2è jour des techdays. J'assisterai à la plénière à distance, du bureau, grâce à la rediffusion en direct, pour rejoindre ensuite le palais des congrès pour quelques sessions, en voici quelques notes.

Langage Axum

Session présentée par Yann SCHWARZ (membre ALT.NET) et Bruno Boucard.

Ce fût une très bonne présentation en binôme sur le sujet de la programmation parallèle (sujet qui m'intéresse car me rappelle un peu ma jeunesse pendant mes études) et particulièrement sur Axum, un DSL dédié à ce délicat domaine.

Etat des lieux

Chez MS, Windows server supporte jusqu'à 256 coeurs, la fréquence en "herz" n'est donc plus le seul critère pour les performances d'applications.

On pose les difficultés actuelles pour le traitement // :

Exemple par un calcul matriciel en //, présentation d'un code C++ : insatisfaisant car compliqué, bien souvent source d'erreurs dans l'algo, paramètre statique pour le nombre de coeurs à utiliser, inmaintenable (et rend donc non sereine toute modification).

La programmation // : il est difficile d'assurer la fiabilité et l'exactitude d'un système qui utilise des locks : peut rendre plus lent l'exécution du code, un constat : le lock coûte cher.

Vient ensuite un exemple sur l'asynchronisme :

exemple trivial, pattern sur les threads : BeginInvoke + callback (EndInvoke) : problème : pas lisibilité ds le code (qui appelle qui, qui appelle quoi)
utilisation de InterLocked Increment/Decrement + BeginInvoke / EndInvoke : un peu plus lisible

pourquoi est-ce si compliqué ? les langages impératifs ont été faits pour des appels synchrones, seul hic : en asynchrone, on perd l'intention du code (lisibilité, quel portion de code fait quoi ?)

Nouvelles approches

Une liste de quelques nouvelles approches sur la programmation // :

.NET 4 : Task Parallel Library (TPL) : abstraction du découpage en threads
Atomicité : casse-tête : on s'inspire des bdd transactionnelles pour avoir de la mémoire transactionnelle : STM.NET (en incubation chez MS), Haskell, Clojure : bien mais trop complexes
approche données, on ne touche plus à rien : tout est immuable, fonctionnel pur : Erlang, Haskell
le modèle "acteurs" : communication uniquement par messages entre acteurs : pas de données partagées, messages asynchrones, traitements distincts et isolés : Erlang (langage dans le Mainstream, utilisé dans les commutateurs téléphoniques) et Axum.

Comme souvent, à chaque besoin son modèle de programmation :

données : TPL, PLINQ
tâches : TPL
flux données : Axum (approche workflow)

Principes Axum

un DSL au parfum C#
repose sur la BCL (Base Class Libraries)
au stade expérimental : en incubation chez MS

les concepts :

domaine : périmètre des données partagées entre agents
agent (ou acteur) : unité de traitement qui communique via messages
channel : modalité de conversation entre agents (contenus dans un domaine)
schéma : format des messages échangés (doit être sérialisable, et donc immuable)

structure d'un système Axum

Les domaines contiennent des agents, les domaines communiquent entre eux par channel, on privilégie la composabilité. Une application est découpée en domaines, les états du domaine sont accessibles par les agents via des channels asynchrones.

Après les bases posées, arrive une démo, un ping pong entre agents, cela permet de découvrir le DSL, et les mots clés de ce dernier pour décrire les traitements.

Un programme axum a une extension .ax (utilisation de l'assembly Microsoft.Axum)

Quelques mots clés du DSL: domain, agent, channel, receive

Un extrait d'un code Axum

public MainAgent()
{
   var pp = PingPong.CreateInNewDomain();
   for(int i=0; i<10;i++)
   {
        pp::Pong <-- true;
        receive(pp:Ping);
   }
   pp::Ping <-- false;
}
 
public channel Pingpong // ~interface ServiceContract en WCF
{
   input bool Pong;
   output Signal Ping; // Signal = void  
}
 
public agent PingAgent : channel PingPong
{
  public PingAgent() // boucle principale de l'agent, on met souvent tout le code de l'agent dedans
  {
      while( receive(Pong)) // receive bloquant
     {
            Ping <-- Signal; //
      }
      Ping <-- Signal;
  }
}

Axum permet aussi de chercher un agent hébergé sur une autre machine (provider Connect<PingPong> "http://server")

Partage de données : par défaut aucune donnée n'est partagée, un agent doit se déclarer pour consommer la donnée, avec des rôles :

Writer : peut modifier l'état du domaine,
Reader : peut lire l'état partagé.

Une fois les rôles définis, Axum décide du mode d'exécution : parallèle, r/w lock, séquentiel

Axum en action (Dataflow Networks)

exprimer explicitement la séquence de traitement dans le code
Opérateurs pour les patterns de communication : forward, forward-once, multiplex, join, broadcast, alternate sous forme d'opérandes qui ressemblent fort à des smileys :-->, ==>, -<< (Broadcast) , &>-, >>- (Multiplex), -<: (Alternate)

Exemples d'application : traitements de N images, de chat (chat de facebook développé en Erlang car des millions en //), jeu de la vie

Interopérabilité

utilisation de la BCL uniquement si c'est garanti par contrats (safe ou non-safe) : si des effets de bord sont détectés par le compilateur Axum, ce dernier n'acceptera pas le code
consommé du .NET classique et vice versa

Principe d'Axum : what you see is what you get (principe de moindre surprise)

ASP.NET 4.0 Webforms

Session présentée par Aurélien VERLA (Wygmam)

Intro

les briquent qui se reposent sur ASP.NET Core : Webforms, MVC, Ajax, Dynamic Data, la session abordera uniquement la partie WebForms 4.0

Simplification du web.config et quelques améliorations :

beaucoup de paramètres du web.config sont déportés dans le machine.config
décliné en Debug ou Release : Web.Debug.config, Web.Release.config : pour avoir des paramètres différents selon la plateforme (via tranformation XSLT) (section <compilation xdt:Transform="RemoveAttributes(debug)"/>)

Code snippet pour accélérer l'écriture des controls : exemple sur asp.Label : pré-remplira le attributs (runat, Text, ...) et se positionnera sur l'attribut à remplir : Ctrl+X+K (ou Ctrl+K+X)

Gain bande passante

Quelques améliorations ont été apportées pour réduire la quantité de données qui transite entre le navigateur et le serveur.

rendering de certains contrôles :

       asp:Menu : RenderingMode : pour modifier le rendu : table à ul li en mode list
       asp:ListView : LayoutTemplate rendu optionnel
       asp:RadioButtonList ou CheckBoxList : span par défaut, rendu par liste possible (ul li)
       asp:FormView : RenderOuterTable

ViewState : nouvelle approche sur l'activation ou la désactivation

       page EnableViewState="true|false"
       control ViewStateMode="Enabled|Disabled|Inherit"

ClientID : ClientIDMode="AutoID|Inherit|Static|Predictable" : AutoID : val par défaut, Static : ID contrôle = ID serveur (pas de concaténation avec les noms des contrôles pères), Predictable : pouvoir prédire un identifiant, cas d'une grille (ex ListView) avec N elts (ClientIDRowSuffix : id du groupe)

Autres nouveautés

ASP.NET Chart Control : contrôle de charting (démo System.Web.DataVisualization) - possibilité de le binder à une source - 35 styles différents
Query Extender : asp:LinqDataSource comme datasource : asp:QueryExtender qui pointe sur le linqdatasource

<asp:QueryExtender>
               <asp:SearchExpression DataFields="field" SearchType="">
                      <asp:ControlParameter ControlID="TextBox1"/>
                </asp>
               <asp:PropertyExpression>
                   <asp:ControlParameter GroupID="controlgroupid" />
               </asp>
           </asp>

autres filtres possibles : RangeExpression, orderByExpression, ThenByExpression, CustomExpression

Tips

GridView : EnablePersistedSelection : fait persister la ligne sélectionnée lors d'une pagination
<%: <script>Alert('toto') </script> %> : raccourci : (2 points) : équivalent à Server.HtmlEncode
classe CSS aspNetHidden générée pour les div générées qui englobent
classe CSS aspNetDisabled : pour les controles en mode disabled
classe utilitaire déportée HttpUtility : HtmlEncode, HtmlDecode, UrlEncode, UrlDecode, plus besoin d'appeller HttpContext...

SEO

Routing : apport des friendly urls : System.Web.Routing : MapPageRoute("nom","chemin/{id}","~/verspage/mapage.aspx")

fonctionnalités : RouteValue::id, RouteUrl::id=32, RouteData.Values, RedirectoToPermanent("lab",new {id=1}) : pour générer des HTTP code 301, Page.MetaKeywords, Page.MetaDescription

Détecter et éviter les fuites mémoires en .NET

Présentée par Yann SCHWARTZ, Fabrice MARGUERIE (de metaSapiens). Session très didactique qui m'a plu car ce type d'erreurs sont souvent communes (pour l'avoir expérimenté). La session est basée sur un article écrit par FM sur DNG.

Les principes

la mémoire du processus : la pile, le tas
le Garbage Collector : fonctionne lorsque l'objet n'est plus référencé nul part - ce qui retient les instances (causes) : références statiques, GCHandles (pont entre le managé et le non ménégé), Références des piles (une pile par thread), Finalization queue
fuite de mémoire : type particulier de consommation de mémoire non intentionnelle

Rappel : en .NET : des objets accessibles par au moins une référence ne seront pas relachés par le GC

une goutte d'eau n'est pas un problème, mais le goutte par goutte peut amener une grosse fuite

Les détecter

se concentrer sur nos classes à nous et non celles du framework

Démo application PhotoLight en winforms : ouvertures de fenêtres qui augmentent la mémoire, qui ne redescend jamais, même en forcant le GC

outils pour pouvoir qualifier avec des niveaux de diagnostic différents

  - analyseur de perfs Windows (PerfMon) : Processus, Octets privés pour l'application PhotoLight
  - vue haut niveau, audit général : dotTrace
  - + en détail : .NET Memory profiler
  - pour les explorateurs : WinDbg

- dotTrace : profiling de perf ou de mémoire. Dump memory pour une photo de la mémoire par type d'objets, shortest root paths (qui tient une référence d'un objet ?).

2 approches :

Approche par Namespace (Dump) pour voir nos objets applicatifs (et non ceux des assembly MS) - Merged Shortest pour remonter vers les objets qui maintiennent une référence
Approche différentielle entre 2 photos mémoire (Mark) : voir les objets qui persistent alors qu'il n'y a plus besoin

cause dans la démo (ouverture d'une image, OptionsForm): abonnement à un évènement statique InstalledFontsChanged dans la fenêtre OptionsForm de l'appli sans jamais se désabonner : la fenêtre dans laquelle on s'est abonné à l'évènement n'est donc jamais désallouée (OptionsForm) - solution : se désabonner ds le dispose : Disposed+=InstalledFontsChanger-=method

- .NET Memory Profiler : permet d'avoir une liste de conseils, plus puissant que dotTrace mais moins user friendly

Profil application pour s'attacher à l'exécutable

cause dans la démo (ouverture options de l'appli, DetailsForm) : analyse le code et alerte - Shortest root path (chemin des références des objets) - abonnement à un évènement (non statique) de la fenêtre mère (qui vit tout le tps donc) sans désabonnement - solution : se désabonner dans la fenêtre fille à cet évènement qui pointe vers la fenêtre mère (MainForm) (Disposed-=evt)

Cas récurrents de causes de fuites mémoire : évènements et problème de fuites invisibles (ou moins détectables) car dépendances inversées

- WinDbg : installation minimale, permet d'explorer un dump mémoire

Extensions : Sos.dll : permet d'examiner la mémoire managée, s'attacher à un process puis en ligne de commandes.

       .cmdtree d:\cmdtree.txt
       .loadby sos mscorwks;
       .load sosex

Exemples de commandes à connaitre :

!DumpHeap : liste des instances du tas
!DumpObject
!GCRoot : trouve l'instance racine d'une instance (réf)

!DumpHeap -stat (pour ordonner)
!DumpHeat -stat -type PhotoLight (filtrer par type)
!DumpHeat -mt idclr (colonne MT)
!do idclr (do watch)
!GCRoot idclr (qui maintient cette réf)

cause dans la démo : menu = new ContextMenuStrip() qui crée un abonnement évènement : dépendance cachée - solution : appeler menu.Dispose() explicitement ou ContextMenuStrip(this.components)

- Process Explorer : affiche les process .NET en jaune, puis compteur de perf de l'appli : .NET CLR loading pour voir les objets chargés

bug ds. new XmlSerializer avec le 2è para new XmlRootAttributes("settings") : n'est plus en cache

Causes possibles des fuites mémoire

attention aux réf. statiques - évènements statiques
évènements sans désabonnement
Dispose non appelé
code compilé à la volée (XSLT pré-compilé) avec System.Reflection.Emit ou CodeDom

Prévenir

analyse statique (NDepend)
chaque += est un ennemi => utiliser les -=, using et Dispose, WeakEvents (réf faibles), EventBroker
ou relancer l'appli par le recyclage de pool ds IIS par ex (approche pragmatique) (NB : très utile, je peux vous le dire)

Slides et sources

Déjà disponibles, merci guys

Techdays 2010, jour 1

zorky — Tue, 09 Feb 2010 22:54:00 +0100

Les techdays, dont c'est la 4è édition, c'est 17 000 inscrits sur les 3 jours, l'évènement technique Microsoft de l'annèe, la plus grosse en France voire en Europe.

Les techdays c'est un moyen de se tenir à jour des nouveautés ou dernières tendances de Microsoft, sur la plateforme .NET ou le développement me concernant. C'est également un moment privilégié, pour nous gens du métier, ingénieurs, développeurs / codeurs, de se retrouver entre nous, sur des sujets qui nous passionnent, et peut-être également sortir d'un cadre où nous sommes pas toujours bien reconnus.

Quelques notes prises durant ce premier jour.

Si vous avez un peu de temps, vous pourrez visionner les webcasts des techdays 2009 à cette adresse, en attendant ceux de 2010.

Silverlight 4 : cas pratique du mode déconnecté

Présentée par Winwise (par Zied et Arnaud Auroux) : la plus intéressante de la matinée de mon point de vue. Au delà de Silverlight et du mode déconnecté, une approche IoC fût abordée, via Unity, afin de changer le provider utilisé pour le CRUD selon le contexte d'utilisation (connecté / déconnecté).

Cette approche, par interfaces, permet notamment d'éviter pas mal de mauvaises pratiques (et d'améliorer in fine le développement logiciel) : ne plus rendre monolithique un projet, améliorer sa maintenance, réutiliser certaines couches et enfin, rendre testable le projet.

Quelques mots clés :

IoC via Unity (qu'il faudra que je teste, versus Castle Windsor),
mode connecté / déconnecté : Isolated Storage, permet un stockage dans Silverlight (1 Mo ou 25 Mo en mode Out-of-Browser),
pattern MVVM qui est le modèle de développement en couches d'application WPF ou Silverlight, similaire à du MVC
Sync Framework pour synchroniser les données entre les 2 modes : fournit des providers mais aussi la possibilité d'en implémenter un (FullEnumerationSimpleSyncProvider)

Les nouveautés de C#4

Salle pleine pour Mitsu. Pour ma part, du déjà vu aux Microsoft days 2009, mais cela ne retire en rien au talent du speaker et passionné de notre langage préféré. On trouvera les avancées suivantes :

dynamic : avec ce nouveau type, C# fait une entrée dans les langages dynamiques. Une classe abstraite est disponible pour développer un binder : DynamicObject
paramètres optionnels et nommés
co / contra-variance : sur les interfaces, 2 nouveaux mots-clés : out et in permet du transtypage (classe mère / fille) qui n'était possible pas avant selon le sens
Expressions : utilisation des Action rendu possible

Entity Framework 4

Session présentée par http://blogs.access-it.net et Matthieu MEZIL

Evolution d'EF : EF1 : approche bottom-up (bdd -> objet), EF4 : possibilité top - down (objet -> bdd)

Quelques nouveautés EF4 :

prise en compte des FK
Lazy loading
utilisation de POCO possible (Plain Old Clr Object)
entités self-trackés (état de l'entité embarquée dans cette dernière, cas d'utilisation en WCF pour des scénarios n-tiers)
CSDL (fonctions SQL)
ajout de règles de validation lors d'enregistrement
Model first
Templates T4 : existe depuis Visual Studio 2005 et n'est pas propre à EF : permet d'écrire des modèles pour générer du code

Je n'ai pas été fonciérement convaincu par la future version d'Entity Framework, elle arrive péniblement au niveau de NHibernate 2.1.2 et encore, je reste à convaincre.

Le principal avantage d'EF sur NHibernate reste l'apport d'un designer pour construire son modèle, et générer ainsi les classes de mapping, ainsi qu'un provider Linq plus abouti mais la version 3.0 de NHibernate devrait combler ce "retard" (car il existe bien un provider Linq to NHibernate mais le développement n'est pas dans le Core du framework, il peut souffrir de défauts).

Bing Maps

Session en anglais par Chris Pendleton

Assez bonne session avec une démo de bing maps en Silverlight où je reste toujours impressionné par le Deep Zoom, efficace et d'une mise au point terrible. L'API Bing maps est utilisable sur les différentes technos : Silverlight control, Ajax control, services Web et MapPoint Websvc.

Un site, qui apporte une réelle valeur ajoutée au développeur, permet d'avoir rapidement des exemples de codes, prêts à l'emploi, une aide précieuse pour commencer quelques dévs. :

Un site démo pour un affichage de statistiques sous forme de graphiques.

OpenID, Google, Yahoo, Orange, MyOpenID, Facebook, LiveID and me : l'authentification à moindre frais

zorky — Thu, 28 Jan 2010 20:15:00 +0100

Préambule

J'admets : j'ai un penchant, non pas pour la bière (quoique) mais pour les standards, protocoles et autres APIs, ouverts dans la mesure du possible.

Il reste toujours préférable de respecter les standards qui sont établis par des instances du type W3C pour ce qui concerne le Web, IETF pour tout protocole lié à Internet (TCP/IP, SMTP, ...) sous forme de RFC, ou encore les standards de fait : développé par une société qui l'a libéré afin qu'il soit adopté par la suite par le plus grand nombre, souvent sous forme d'une fondation (qui regroupe un consortium de sociétés / d'organismes).

Je me suis intéressé dernièrement à OpenID, standard ouvert d'authentification, Wikipédia définit très bien ce protocole et standard ouvert :

 OpenID est un système d’authentification décentralisé qui permet l’authentification unique, ainsi que le partage d’attributs. Il permet à un utilisateur de s’authentifier auprès de plusieurs sites (devant prendre en charge cette technologie) sans avoir à retenir un identifiant pour chacun d’eux mais en utilisant à chaque fois un unique identifiant OpenID

La fondation OpenID regroupe les grands acteurs du Web (Google, MS, FB, ...une belle liste), avec l'objectif que ce standard soit utilisé et déployé vers le plus grand nombre de sites.

OpenID prend également part à OpenStack, pile de standards pour le Web (OpenID, OAuth, OpenSocial ou sur Google code OpenSocial, XRDS-Simple : utilisé par OpenID ou OAuth, pour la découverte dynamique de services, PortableContacts), qui se schématise par l'image suivante :

La base d'OpenID : l'URL

l'adresse Web du fournisseur OpenID : sa carte de visite

Dans sa version 1.x, le protocole est basé sur une URL qui représente l'identité de l'utilisateur. Parmi les fournisseurs OpenID, nous trouvons parmi le plus connu MyOpenID, mais on pourrait citer également ClaimID, MyID.is, Ziki, Verisign.

On voit souvent le champ suivant avec le logo représentatif d'OpenID qui spécifie que le site prend en charge ce standard :

L'avantage d'une URL est qu'elle peut être utilisée aussi comme une carte d'identité : les URL suivantes représentent mon identité ou du moins ma carte de visite, voire ma carte sociale (au sens réseau) :

http://zorky.myopenid.com : en plus d'informations telles qu'email, localisation, MyOpenID fournit également une vCard pour importer directement ses informations sous Outlook par exemple,
http://www.google.com/profiles/zorky00 Google profiles, sous sa forme URL : permet une personnalisation de ses différents réseaux sociaux ou sites/blogs, ainsi que sa localisation, photos Flickr, mini-CV,
http://www.ziki.com/zorky : le plus abouti avec Google mais ne semble pas fonctionner sur tous les sites,
http://zorky.pip.verisignlabs.com : Verisign offre une grande marge de personnalisation de sa carte de visite OpenID, et de télécharger sa CardSpace (uniquement sous Windows). Verisign fournit une extension Firefox pour remplir et s'authentifier automatiquement par son URL,
http://myid.is/olivier.duval.id : simple, certifie vos sites/blogs,
http://claimid.com/zorky

la délégation d'URL

Lorsque l'on a un domaine Internet et un ou plusieurs sites, ces derniers servent aussi de carte de visite. OpenID autorise la délégation d'authentification à l'aide d'un jeu de balises link dans une page HTML.

Par exemple mon site portail http://olivier-duval.info contient les balises suivantes qui font référence à mon compte MyOpenID (zorky.myopenid.com) :

<link rel="openid.server" href="https://www.myopenid.com/server " />
<link rel="openid.delegate" href="http://zorky.myopenid.com " />
<link rel="openid2.provider" href="http://www.myopenid.com/server " />
<link rel="openid2.local_id" href="http://zorky.myopenid.com " />

ces balises dans la section head de la page d'accueil auront pour effet que je puisse utiliser olivier-duval.info comme adresse / identifiant OpenID sur les sites qui proposent l'authentification OpenID (principale ou en alternative), pratique : j'expose ma carte de visite en même temps que la possibilité de m'authentifier.

le challenge : améliorer l'expérience utilisateur OpenID (OpenID UX)

OpenID 2.0 et la fonctionnalité Directed identity

OpenID 2.0 a apporté notamment les nouveautés suivantes (on pourra lire cet article sur la v2.0) :

directed identity
attribute exchange extension (AX)

La 1ère était pour Google et Yahoo, la condition au passage à OpenID, la killer-feature et cela en est bien une.

Avec OpenID 1.1, l'utilisateur s'identifie grâce à une URL, où l'identifiant utilisateur est embarqué dans cette dernière, comme nous l'avons vu précédemment (dans mon cas : http://olivier-duval.info ou http://zorky.myopenid.com). Pour le commun des mortels, cette approche peut paraitre perturbante : saisie d'une URL puis une authentification par login et mot de passe.

Avec OpenID 2.0, on ne précise plus l'URL utilisateur, seule l'adresse du provider suffit (en langage technique l'OpenID end-point) : l'application fournit l'URL du provider (le paramètre openid.claimed_id envoyé au fournisseur contiendra alors la valeur http://specs.openid.net/auth/2.0/identifier_select au lieu de l'URL OpenID utilisateur) qui se chargera d'authentifier l'utilisateur (par login/mot de passe), le provider répondra à l'application cliente en lui fournissant l'URL OpenID de l'utilisateur.

Concrétement, cela permet le développement de widgets contenant des icônes cliquables (RPX l'a compris depuis longtemps), que nous voyons de plus en plus sur les sites : cela améliore l'expérience utilisateur (OpenID UX), par une approche plus simple sous forme d'un clic sur une image plutôt qu'une saisie d'URL.

On pourra alors trouver ce type de bannières où d'un clic l'utilisateur est redirigé vers le fournisseur de son choix :

des librairies jQuery commencent à naitre : sur jVance.com, OpenID-selector, ou en développer une spécifique pour intégrer Orange.

Quels fournisseurs ?

Tous les fournisseurs OpenID n'implémentent pas tous OpenID 2.0 et la fonction directed identity. Parmi les fournisseurs qui ont adopté la spécification OpenID 2.0 (avec le directed identity) et leur end-point (URL) d'accès, sont nominés (tous ont été testés) :

Google : https://www.google.com/accounts/o8/id (par l'utilisation d'une requête XRDS pour l'obtention du end-point réel pour la redirection OpenID, cf. l'API Google OpenID),
Yahoo : http://me.yahoo.com - option : peut nécessiter la mise en place d'un fichier XRDS pour retirer le message d'avertissement sur le site demandeur (non "vérifié" par défaut, cf. cette intéressante question),
Flickr (appartient à Yahoo) : http://www.flickr.com,
Orange : http://openid.orange.fr (http://orange.fr devrait également fonctionner),
MyOpenID : http://www.myopenid.com,
Verisign : https://pip.verisignlabs.com,
MySpace : http://www.myspace.com

Sur le blog de JanRain (RPX), il est intéressant de constater que sur 173 000 sites qui utilisent leur widget, 37,4 % des utilisateurs préférent Google (source)

Avantage et intérêt ?

Personnellement je suis constamment connecté sur mon compte Google, pour lire mes mails, mes flux, mon calendrier, voire éditer des fichiers. Lorsque je vais sur un site qui accepte Google comme authentification OpenID, il suffit d'un clic pour y accéder car je suis déjà connecté sur Google, doublement pratique :

je ne retiens et ne conserve qu'un login (mon email) / mot de passe, ma connexion est facilitée et rapide car j'ai un usage important des services Google (cela pourrait en être autant avec Yahoo, MySpace ou Orange).

Concernant Google, une partie de l'URL renvoyée à l'application cliente (RP : Relying Party) est hashée sur le domaine appelant et diffère donc selon l'application qui effectue la demande d'authentification.

Par exemple, si je teste mon authentification Google sur mon essai RPX, j'obtiens comme identifiant OpenID www.google.com/accounts/o8/id?id=XXXXwkvXsnU5vv4V7ECA7MVcqx4cz1GdQJ-yUA , par Stackoverflow, un autre identifiant www.google.com/accounts/o8/id?id=XXXXkyhuj2bdptserwktuerhwtotmxwtztguo, différent donc. Cela peut être gênant d'unifier le "login" utilisateur Google pour plusieurs applications Web (ie : sur des domaines différents). Google calcule le hash contenu dans l'URL retournée selon le paramètre openid.realm (qui contient le domaine / hôte RP qui effectue la requête OpenID), c'est très bien expliqué à la section Request authentication response.

Internautes : quelle utilisation ? Directed Identity ou par URL ?

Lorsque le site ne propose pas une authentification Google, j'utilise mon adresse http://olivier-duval.info, mais de plus en plus de sites proposent Google ou Yahoo comme authentification principale. On pourra citer StackOverflow (et ses avatars : http://serverfault.com http://superuser.com , ça manque de SSO dans ce cas d'ailleurs), Diigo, UserVoices, Plaxo, FriendFeed - soit ils proposent 1 seule identité, soit N identités alternatives (1 compte local + n comptes OpenID du type Google, Yahoo, ...) : on nous donne la liberté de choix, et j'aime cette démarche.

Convenons que pour l'utilisateur lambda, il est plus simple d'utiliser des icônes qu'une URL, moins long aussi à saisir.

Sites qui gèrent des comptes: compte local ou alternatives avec OpenID ?

Des sites ont choisi de n'avoir que des comptes externes (par exemple Stackoverflow), tout en proposant un 2è compte OpenID pour se connecter (si le 1er fournisseur venait à tomber par exemple).

D'autres, Diigo (possibilité d'autant de comptes supplémentaires que l'on souhaite), BaseCamp (1 seul OpenID), Plaxo, Facebook (autant que l'on souhaite), ...ont choisi OpenID comme compte alternatif au compte local créé lors de son inscription.

Le 1er est le plus risqué, il faut au moins proposer la possibilité d'enregistrer un 2è compte OpenID, car nous restons tributaires du fournisseur OpenID (Google, Yahoo, ...), le compte local, lui, fonctionnera (presque) toujours.

aide à la pré-inscription

Un autre usage d'OpenID peut concerner la pré-inscription. Lors de la connexion avec son compte Google, le site RP / demandeur peut solliciter des champs de retour, du type l'email, le nom, etc. Cet échange est décrit dans la spécification OpenID SREG qui inclut une liste finie de champs. Dans ce cas là, on pourrait pré-remplir quelques informations sur le futur abonné au site. Un billet sur le sujet (par FB Connect ou Twitter mais l'idée reste la même).

A titre d'information, on pourrait aller bien plus loin dans l'échange d'attributs entre un site client et un provider, en se basant sur OpenID 2.0 et la spécification OpenID Attribute Exchange (cf. ce billet sur le sujet).

et les autres fournisseurs : Facebook, Microsoft (LiveID) ?

Facebook

Facebook a pris la voie d'un protocole propriétaire pour l'authentification : Facebook Connect. Malheureusement je dirais, car cela ne couterait pas très cher de passer à OpenID en tant que fournisseur (OpenID Provider / OP), et tellement appréciable. J'espère que Facebook deviendra un jour OP avec la fonctionnalité directed identity, cela éviterait d'implémenter un protocole supplémentaire.

En revanche, FB (ayant rejoint la fondation OpenID) autorise le RP (Relying Party) en ... mode automatique : il suffit de lier son compte Facebook avec ses différents fournisseurs OpenID, et dès que vous accéderez à la page d'accueil http://www.facebook.com , si vous êtes déjà connectés (sur Google par exemple) vous serez automatiquement authentifier à Facebook, pas mal pour le coup, riche idée j'ai trouvé. FB stocke tout ce p'tit monde dans un cookie (openid_p), cela n'est valable donc uniquement sur le poste courant, à moins de s'être au moins connecté 1 fois sur FB sur le poste afin qu'il puisse positionner le cookie.

Pour cela, il suffit d'aller dans Paramètres > Compte > Comptes liés. L'idée est séduisante, sans compter l'ergonomie de sélection du fournisseur que je trouve particulièrement réussie (pour la reprendre à mon compte d'ailleurs) :

Microsoft / LiveID

Microsoft qui a adhéré à la fondation, a entrepris (en Community Tech Preview) le passage des comptes LiveID en OpenID. Aux dernières nouvelles, ce n'était pas actif sur les vrais comptes LiveID, mais toujours en test (cf. le site de test, pas de nouvelle, bonne nouvelle ? 500 millions de comptes sont concernés, il serait dommage de ne pas en profiter un jour).

Mais selon la newsletter de la fondation, il y a un bon espoir : cf. la partie OP Progress : "Microsoft committed to becoming an OpenID Provider in 2010"

librairies

Quelques librairies pour nous codeurs :

Java : open4java
PHP , Ruby ou Python édités par RPX
plus ici
et je finirais par .NET : l'excellente librairie DNOA (il y a également ExtremeSwank mais déconseillée car la version RP est compromise et n'est plus maintenue) qui implémente totalement les spécifications d'OpenID v2.0, contrairement à ces concurrents :

le site officiel DotNetOpenAuth : OpenID 1x et 2.0, RP et provider, AX, implémente la fonctionnalité directed identity
les sources
le groupe : pour avoir posé quelques questions, le principal contributeur (travaille chez MS du côté de la XBox ;)) répond assez rapidement
de nombreux projets exemples, soit en ASP.NET MVC, soit en ASP.NET WebForms
DNOA de son petit nom, implémente également le protocole OAuth, API standard d'autorisations, très utilisée sous Twitter (permet d'utiliser une API par le biais de son compte mais sans laisser ses logins / mot de passe au site tiers utilisateur de l'API), et prend en compte InfoCard
expérience utilisateur avec jQuery : http://openidux.dotnetopenauth.net

N'hésitez pas pour voter des évolutions sur l'UserVoice du projet (les implémentations de FB Connect ou de MS LiveID seraient un très bon début).

OpenID : la solution miracle à l'authentification ?

Bien entendu que non. A défaut d'être parfait, cela a le mérite d'essayer de sortir un standard qui tente de répondre à un besoin classique et récurrent sur Internet : l'inscription et l'utilisation de logins et mot de passe sur des applications ou services. Personnellement, je dois être inscrit à environ 300 sites, avec pour chacun des règles différents pour le choix du login (email, login, déjà pris, ...), mot de passe (trop court, pas assez compliqué, ...) et j'en passe.

L'essayer, c'est l'adopter, d'autant plus qu'avec la fonctionnalité directed identity, soutenue par Google, Yahoo, Orange & co (et bientôt AOL en 2010), l'expérience utilisateur devient bien plus simple.

Quelques sorties 2010 : Castle Windsor, Dokuwiki, Sympa, jQuery

zorky — Sun, 24 Jan 2010 11:33:00 +0100

Quelques mises à jour à effectuer pour 2010 :

IoC : Castle Windsor 2.1.1 : ajout du support Silverlight, performances, ...vous avez des besoins ? n'hésitez pas à les exprimer sur UserVoices,
Wiki : bon, pas vraiment 2010 mais presque : dokuwiki Lemming du 2009-12-25 patch c : moteur wiki que j'affectionne car il reste simple (sans base de données) et offre une extensibilité appréciable (même s'il est développé en PHP), voir les changelog
Listes de diffusion : Sympa version 6.x : SYMPA est un serveur de listes de diffusion, doté d'un API SOAP, et d'innombrables fonctionnalités : authent/ SSO (CAS), moteur de modèles, antispam, hautes-performances / réparti, listes dynamiques, sources de données diverses et variées (LDAP, SQL Server/..., fichiers locaux ou distants, ...) Il est maintenu (développement en Perl) par des français et utilisé de plus en plus aux US.
javascript : à moins d'avoir eu une grosse coupure Internet, si vous n'êtes pas au courant : jQuery 1.4

Les 10 125 extensions Chrome à installer d'urgence

zorky — Fri, 22 Jan 2010 12:30:00 +0100

La pub subliminale de Google dans les transports, journaux, arrêts de bus, ..., concernant Chrome a eu raison de mon libre arbitre, je commence à installer bon nombre d'extensions Chrome, pas 10 125, mais seulement 11 pour l'instant.

Gros consommateur de services Google (aux dépends de ma liberté donc), du type GMail, Google Calendar, documents, apps, etc, Chrome reste une bonne alternative à Firefox lorsqu'on n'a pas besoin d'extensions pour du développement Web (Firebug, Firecookies, YSlow, etc), il devient alors plus léger que son concurrent.

Les extensions Chrome que j'ai installées récemment, en rapport aux services Google ou non :

Goole Mail checker
Google reader checker
Google Calendar Popout
RSS Subscription Extension
Diigo Bookmarks : Diigo m'enregistre automatiquement mes favoris dans delicious, donc pas besoin d'extension pour ce dernier
Feedly
Bit.ly : le site par excellence qui vous raccourcit vos URL
Goo.gl : le service d'URL raccourcis de Google
Kutano : client Twitter
Fittr : très pratique pour Flickr : accès facilité aux EXIF, modale pour un affichage plus grand de la photo, raccourcis http://flic.kr, vue sur fond noir
Tumblr pour les utilisateurs de Tumblr, permet de lire les blogs que l'on suit, et également de publier
Evernote pour les inconditionnels comme moi de la note partout sur tout

ce qui est pas mal sous Chrome, contrairement à Firefox, c'est qu'il n'y a pas besoin de relancer le navigateur.

En revanche, l'Extension Firefox, avec un grand E, qui manque à Chrome reste Ubiquity, dur de s'en passer quand on y a goûtée.

Rétrospective 2009

zorky — Fri, 01 Jan 2010 09:25:00 +0100

Bonne et heureuse année 2010 ! encore plus de web, de développement et de réseaux sociaux !

Cette année 2009, avec l'arrivée de ma petite Amélia, le blog fût moins riche en billets car très occupé, j'essaierai de corriger ça pour 2010, cela fera au moins une bonne résolution. Seulement 62 billets contre 130 pour l'année précédente. Comme l'année dernière, un résumé par thématiques des billets.

du .NET :

XLinq vs. Xpath
méthodes find et le dynamic de C#4
NHibernate : paginaton et tri
NHModeler : modéliser ses modèles pour générer les fichiers ad-hoc NHibernate
IoC Castle Windsor et repository generic
Linq inside
plein de liens sur NHibernate et ici aussi
WCF, 1ers pas et des liens sur WCF / REST et GData

JQuery, Piwik, Google, API

jQuery et l'autocompletion
Google migre les comptes Feedburner, suite à son rachat, essentiel pour son blog
APIs, Mashup & co
exploiter l'API de Piwik avec Google docs
comment être sûr et certain de ne plus être indexé par Google (et comment le faire)
Piwik et jTemplates / jQuery

du Web, limite 2.0, du système

Facebook, Twitter et moi et moi...
avec OpenID
du SaaS avec EC2
des astuces pour augmenter les performances de ses pages avec Apache
revue du Synology 209+ II sur lequel le blog tourne dorénavant

du débat

Forum 2.0
XWiki Marketing et Opensource : même si on est en droit de se poser des questions sur un potentiel conflit d'intérêts entre les modèles Entreprise / Communautaire de pas mal de solutions : JBoss (RedHat), MySQL (bientôt Oracle), ...personnellement, tant qu'à utiliser de l'Opensource, je préfère que le projet soit géré par une fondation (Apache par exemple) ou qu'il n'y ait aucune société derrière, dans le cas contraire la neutralité n'y ait pas, il reste une ambiguïté. Je préfère par exemple le modèle d'Atlassian sur leurs produits, même si ce n'est pas Opensource et que l'on peut tout de même obtenir les sources, on sait à quoi on s'attend.

un sondage pour toi, codeur de l'extrême : sur 142 votes, 44 % pensent qu'il faut 5 ans pour être un bon codeur, 25 % la vie n'y suffirait pas, 16 % au moins 10 ans.

de la lecture avec Ruby, ou encore, tentons d'éviter les 25 erreurs de programmation les plus dangereuses.

à la recherche d'un nouveau portable, j'ai pu investir dans un p'tit monstre de puissance.

Pour 2010, du Web, Web 2.0, .NET (Visual Studio 2010 / C#4, Silverlight 4), j'essaierai de participer plus aux rencontres Alt.NET ou autres petits déjeuners sur les thèmes de l'agilité, et pour le blog, je m'orienterai bien vers un thème ultra-léger, y'a plus qu'à.

Optimisations Apache sur un NAS Synology 209+II : deflate, cache expires et APC

zorky — Sun, 20 Dec 2009 15:43:00 +0100

Préambule

Avec l'arrivée de mon nouveau NAS 209+II, bien qu'il soit plus véloce en termes de CPU et de mémoire, il fallait tout de même optimiser les flux, étant hébergé chez soi , la bande passante n'équivaut pas à un hébergement chez un fournisseur. Aussi, j'ai dû optimiser un minimum le serveur Apache afin d'héberger le blog, pour réduire la quantité de données entre le navigateur des visiteurs et le serveur, cela se révèle important malgré tout : au bout de 4 secondes, un visiteur s'en ira.

Des plugins Firefox permettent d'analyser une page afin d'avoir des conseils et des actions à entreprendre : je suis parti sur PageSpeed, qui offre, en plus du diagnostic habituel et des conseils, des solutions concrètes, applicables immédiatement : les CSS, JS, et images réduites / compressés, que l'on pourra prendre directement afin de les placer sur le serveur.

Apache sur un NAS 209+II

Un mot très important lorsqu'on développe une application Web : le cache, sans cache, vous courrez à la catastrophe. Le moteur Dotclear intègre en natif un cache applicatif mais cela ne suffit pas, Apache offre quelques modules qui permettent d'aller plus loin.

APC

Sur le Synology, il intègre la possibilité d'activer APC, qui est un cache PHP qui permet de précompiler le code, pour gagner quelques ms, à activer bien entendu.

deflate

Le module mod_deflate sert à compresser le flux entre le serveur et le navigateur, cela fera donc travailler un peu plus le poste client. A l'approche des fêtes, comme on va tous en changer, pour avoir des machines de guerres, je ne suis pas trop inquiet La configuration ci-après est transposable vers n'importe quel Apache d'autres distribution (Debian, etc...).

Sur le Synology, la configuration Apache utilisateur (il y a aussi une configuration propre à la partie administration, sur le port 5000 du DSM) se trouve dans le fichier /usr/syno/apache/conf/httpd.conf-user

Exemple de configuration pour activer le module deflate, sur le HTML, XML, JS, CSS ou le TEXTE, il suffira de relancer Apache (/usr/syno/etc/rc.d/S97apache-user.sh restart) pour voir le résultat :

LoadModule deflate_module modules/mod_deflate.so
 
<IfModule mod_deflate.c>
        DeflateCompressionLevel 2
 
        AddOutputFilterByType DEFLATE text/html text/plain text/xml text/javascript text/css application/javascript
        SetOutputFilter DEFLATE
        Header append Vary User-Agent env=!dont-vary
 
        AddOutputFilter DEFLATE js css
        BrowserMatch ^Mozilla/4 gzip-only-text/html
        BrowserMatch ^Mozilla/4\.[0678] no-gzip
        BrowserMatch \bMSIE\s7  !no-gzip !gzip-only-text/html
</IfModule>

afin de s'assurer que cela fonctionne (c'est mieux), on pourra tracer la compression qu'effectue deflate en ajoutant dans le IfModule cette partie :

DeflateFilterNote Input input_info
        DeflateFilterNote Output output_info
        DeflateFilterNote Ratio ratio_info
        LogFormat '"%r" %{output_info}n/%{input_info}n (%{ratio_info}n%%)' deflate
        CustomLog /var/log/apache_deflate_log deflate

On aura alors accès à la trace du fichier /var/log/apache_deflate_log deflate . Un extrait des résultats sur le billet qui concerne Thor (mon petit portable), les chiffres de la fin X/Y (Z%) signifient : X : quantité après compression, Y : quantité avant, Z : taux de compression :

"GET /?post/clevo-d900f-portable-gamer-i7 HTTP/1.1" 10601/31625 (33%)
"GET /themes/graylvetica/style.css HTTP/1.1" 3130/10115 (30%)
"GET /themes/default/print.css HTTP/1.1" 532/993 (53%)
"GET /themes/default/js/jquery.js HTTP/1.1" 24420/73690 (33%)
"GET /themes/default/js/jquery.cookie.js HTTP/1.1" 458/994 (46%)
"GET /themes/default/js/post.js HTTP/1.1" 450/1133 (39%)
"GET /?pf=dclightbox/style/css/dclightbox.css HTTP/1.1" 812/1996 (40%)
"GET /?pf=dclightbox/style/js/prototype.js HTTP/1.1" 12559/47603 (26%)
"GET /?pf=dclightbox/style/js/scriptaculous.js&load=effects HTTP/1.1" 1182/2152 (54%)
"GET /?pf=dclightbox/style/js/effects.js HTTP/1.1" 8051/31969 (25%)
"GET /?pf=dclightbox/style/js/lightbox.js HTTP/1.1" 5792/20044 (28%)
"GET /?pf=lightbox/css/modal.css HTTP/1.1" 304/753 (40%)
"GET /public/d900f/IMG_9694_DxO_raw_copy-th.jpg HTTP/1.1" 10943/11147 (98%)
"GET /public/d900f/IMG_9699_DxO_raw_copy-th.jpg HTTP/1.1" 11183/11368 (98%)

sympa, non ? on pourra jouer sur l'option DeflateCompressionLevel pour varier le taux de compression (1 : basse, 9 : la plus haute), le niveau le plus haut demandera plus de travail de la part du CPU côté poste client.

expires

Le module expires agira sur les entêtes HTTP en indiquant une date d'expiration (que le navigateur interprétera) sur l'élément à transférer, que la navigateur gardera ou non dans son cache.

Tout comme le deflate, se configure dans le httpd.conf-user, exemple de configuration (voir la page d'Apache 2 pour les précisions):

LoadModule expires_module modules/mod_expires.so
 
<IfModule mod_expires.c>
ExpiresActive on
ExpiresDefault "access plus 2 minutes"
ExpiresByType text/html "access plus 120 seconds"
ExpiresByType text/css "access plus 1 month"
ExpiresByType text/javascript "access plus 1 month"
ExpiresByType application/x-javascript "access plus 1 month"
ExpiresByType application/javascript "access plus 1 month"
ExpiresByType image/gif "access plus 1 months"
ExpiresByType image/jpeg "access plus 1 months"
ExpiresByType image/png "access plus 1 months"
</IfModule>

Testons si cela est bien pris en compte, sur l'accès à une image :

sans mod_expires :

$ wget -S http://blog.olivier-duval.info/public/model-nhmodeler.png

  HTTP/1.1 200 OK
  Date: Sat, 19 Dec 2009 14:26:02 GMT
  Server: Apache/2.2.13 (Unix) mod_ssl/2.2.13 OpenSSL/0.9.8k PHP/5.2.10
  Last-Modified: Wed, 07 Oct 2009 20:40:14 GMT
  ETag: "319008f-3e3a-4755e5a960780"
  Accept-Ranges: bytes
  Content-Length: 15930
  Vary: Accept-Encoding,User-Agent
  Keep-Alive: timeout=5, max=100
  Connection: Keep-Alive
  Content-Type: image/png
Length: 15930 (16K) [image/png]

avec, on aura 2 entêtes supplémenaires : Cache-Control: et Expires:

$ wget -S http://blog.olivier-duval.info/public/model-nhmodeler.png

  HTTP/1.1 200 OK
  Date: Sat, 19 Dec 2009 14:24:14 GMT
  Server: Apache/2.2.13 (Unix) mod_ssl/2.2.13 OpenSSL/0.9.8k PHP/5.2.10
  Last-Modified: Wed, 07 Oct 2009 20:40:14 GMT
  ETag: "319008f-3e3a-4755e5a960780"
  Accept-Ranges: bytes
  Content-Length: 15930
  Cache-Control: max-age=2592000
  Expires: Mon, 18 Jan 2010 14:24:14 GMT
  Vary: Accept-Encoding,User-Agent
  Keep-Alive: timeout=5, max=100
  Connection: Keep-Alive
  Content-Type: image/png
Length: 15930 (16K) [image/png]

bien entendu cette technique est valable si le visiteur revient sur la page, cela reste utile pour les éléments partagés.

Conclusion

Avec quelques modules, on pourra optimiser un petit serveur afin qu'il réponde au mieux aux requêtes, afin de contrebalancer des ressources légères, même s'il reste encore un peu de travail à faire, en enlevant tout élément inutile.

Une analyse avec YSlow m'annonce un passage d'une note F à D, objectif, atteindre au moins un C.

NAS Synology 209+ II

zorky — Sun, 20 Dec 2009 12:52:00 +0100

Après 1 an 1/2 de bons et loyaux services de mon NAS 207+ (qui est à vendre sur la baie), passage à la version supérieure : l'excellent 209+ II avec comme objectif de migrer mon blog hébergé sur kimsufi vers le NAS.

Pourquoi changer ? la volonté d'arrêter mon hébergement Kimsufi (très bien mais malgré tout payant et mon blog est au ralenti). En temps normal, un passage sur le 207+ aurait pu être suffisant et être utilisé encore longtemps, mais pour l'hébergement de mon blog et du site index, le tout sous Dotclear, cela demandait des ressources supplémentaires.

J'avais testé le 207+ avec dotclear mais cela ne convenait pas. En revanche, le 207+ avec d'autres moteurs (ou le moteur interne de Blog de Synology) semble être suffisant, voir la liste des logiciels testés.

Spécifications du 209+II

Au niveau des spécifications du 209+II, il est plus véloce, tout en retrouvant toutes les fonctionnalités livrées avec le DSM 2.2, avec ipkg en complément (cf. ce billet pour l'e500 et les sources qui vont avec), le tout sur un RAID-1 de 1 To, un CPU PowerPC 1.06 GHz et 500 Mo RAM

$ cat /proc/cpuinfo
processor       : 0
cpu             : e500v2
clock           : 1066.560000MHz
revision        : 2.2 (pvr 8021 0022)
bogomips        : 133.12
timebase        : 66660000
platform        : MPC8544 DS
Vendor          : Freescale Semiconductor
PVR             : 0x80210022
SVR             : 0x80340011
PLL setting     : 0x4
Memory          : 512 MB

Méthode de migration entre les 2 NAS

Pour le passage du 207+ au 209+II, j'ai opté également pour un changement de disques : de 500 Go à 1 To, compte tenu de mes énormes besoins de stockage. La migration s'est bien déroulée, après bien entendu avoir effectué une sauvegarde totale des données sur mon portable, au cas où.

Méthode que j'ai utilisée pour le passage au nouveau NAS :

installation du firmware avec le logiciel d'installation du 209, avec UN seul disque 500 Go,
mise en place du 2è, il synchronise le RAID-1,
remplacement d'un 500 Go par 1 To : il l'initialise puis synchronise le RAID-1,
remplacement du dernier 500 Go par le 1 To : il synchronise le RAID-1, la capacité reste à 500 Go,
sur l'interface DSM (Stockage / Volume), cliquer sur Augmenter : il étend le volume à 1 To

et voilà, je me retrouve avec toutes mes données sur un volume RAID-1 de 1 To.

Performances

Tests rapides de transferts :

en copie ou en écriture d'un gros fichier (400 Mo), en filaire : 11-13 Mo/s
en copie de fichiers de 20 Mo : 10-11 Mo/s

la charge du serveur ne sourcille pas d'un poil : load average: 0.14, 0.04, 0.00

Les serveurs qui sont lancés : apache, lighttpd, mysql, postgresql, DLNA (serveur multimédia), serveurs de fichiers. Sous htop, on peut voir que le système est réglé aux p'tits oignons et ne consomme...rien :

Blog & co

Pour le passage du blog et du site racine, pas de souci particulier : copie des répertoires, dump SQL. Jusqu'à le DSM 2.2, Piwik ne pouvait fonctionner dessus, car ce dernier utilise PDO, mais à partir du DSM 2.3, Piwik peut tourner dessus, la preuve avec le live visits.

Le DSM offre la possibilité de créer des serveurs Web virtuels via l'interface (Services réseaux / Services Web), ils seront stockés dans /volume1/web, j'en ai créé 2 : blog.olivier-duval.info, et olivier-duval.info.

Bien entendu je n'atteindrai pas les performances d'un Kimsufi, sans compter les coupures possibles d'Internet, mais cela sera grandement suffisant pour l'instant pour mes besoins.

Le NAS Synology, mangez-en, un petit serveur à la maison pour sauvegarder vos données, héberger vos sites, et avec toutes les fonctionnalités qu'il offre (serveur multimédia, téléchargements, photos, iTunes, ...), je pense que je continuerai dans les prochaines séries.

Optimisations

J'ai écris un billet sur les optimisations qui ont été appliquées pour le passage au NAS du blog.

Agenda de décembre 2009

zorky — Tue, 01 Dec 2009 08:15:00 +0100

Les rendez-vous repérés de décembre :

Afterworks des communautés MS le 2 décembre au Charlie Birdy dans le 15è,
petit-déjeuner Octo le 10 décembre sur le thème de cloud computing à l'Atelier BNP Parisbas (lieu très sympa),
Facebook Developer Garage Paris - Le Web Edition le 10 décembre,
soirée Alt.NET Openspace le 15 décembre chez Valtech, inscription via Doodle, voir l'annonce de Robert

Agenda de novembre 2009

zorky — Tue, 10 Nov 2009 08:10:00 +0100

Quelques rendez-vous qui me semblent intéressants :

petit déjeuner d'Octo (gratuit) le 12 novembre sur le thème de l'agilité

Valtech days 2009 le 17 novembre (payant), cette fois-ci, je n'y serai pas : 1 jour de moins pour plus cher (300 € HT), dommage car le programme me semblait intéressant.

Alt.NET Command Query Separation avec Udi Dahan le lundi 16 novembre, en anglais

Conférence sur les Techniques et Stratégies Web, et Ateliers pratiques sur les RIA le 17 novembre de 14h30 à 18h30 au centre de conf. MS à Issy-les-Moulineaux

Bienvenue à Thor, reçu le 29 octobre, il pèse 5,4 kgs

zorky — Sat, 31 Oct 2009 22:14:00 +0100

Après 15 jours d'attente, il est enfin arrivé. Thor de son petit nom, pèse 5,4 kgs, un bien beau bébé. Il va remplacer Victor (Sony VAIO, Centrino Core 2 Duo T2300 1,66 Ghz, 2 Go RAM, 100 Go DD, 15"4), devenu trop lent après 3,5 ans de bons et loyaux services.

Merci aux commentateurs du billet sur ma recherche de portable, notamment Romain et David (fondateur du site portables4gamers, un précieux site !) , j'ai au moins écouté les conseils concernant le SSD.

Commençons par quelques photos du petit qui en impose

Quelques retours rapides

Après avoir pas mal regardé, les configurations haut de gamme en portable, il y en a finalement peu sur le marché : Alienware M17x, Dell XPS m1730, barebone Clevo

Ensuite, c'est une question de besoins et surtout de...budget. Le français moyen met rarement les moyens dans ce qu'il souhaite entreprendre, ce côté "petit joueur" assez agaçant chez nous ou comment escalader une montagne avec des tongs souvent. Personnellement, je considère qu'il vaut mieux attendre pour avoir les moyens pour entamer quelque chose, et là, il fallait attendre pour le budget : le confort n'a pas de prix.

Mes besoins, pour rappel : beaucoup de traitement de photos (ou bientôt de la vidéo ?), consommateurs en CPU et mémoire (CS3, DxO Optics Pro, Lightroom, ...), développement (Visual Studio, SQL Server, virtualisation,...), tout cela demande du multi-coeurs avant tout, bien plus que pour les jeux ou des Core 2 Duo suffisent.

Passons maintenant aux spécifications de la machine, attention, ça pique les yeux :

barebone Clevo D900F wUXGA 17" 1920x1200,
Intel i7 920 (quad coeurs hyperthreadés, 2,66 GHz cache 8Mo, 4,8 GT/s)
NVidia GTX 280M 1Go,
6 Go RAM : 3x2Go DDR3 (1066 / 1366 MHz),
1 DD système 80Go SSD Intel X25-M Postville (G2),
1 DD 500 Go 7200 trs/mn, (reste de la place pour 1 troisième),
graveur DVD, lecteur Bluray,

...toutes les spécifications détaillées chez IL (ou chez le constructeur), le tout sous Windows 7 Ultimate 64bits. L'intégrateur Français Invasion Labs est basé dans le sud de la France, je vous le recommande chaudement, pour son professionnalisme et sa réactivité.

Indicateurs de performance

Quelques chiffres, sur le Clevo (Thor), ou en comparaison avec l'ancien portable (Victor).

Indice Windows 7 : 6,8 (étonnant, c'est la carte graphique qui pêche) :

Score 3D Mark 06 : 12 719

P4G (que l'on trouvera sur le site p4g)

Les disques, le SSD X25-M et le HDD 7200 rpm (en lecture seule, pas de licence HD Tune) :

un ensemble de tests :

Le i7 hyperthreadé est assez marrant à regarder :

Conclusion

Le D900F est une station de travail qui répond aux utilisations les plus exigeantes, mes 1ères impressions sont excellentes, la puissance à l'état pur, il est bien un "desktop replacement" pour ceux qui ne souhaitent pas de PC de bureau, il rendra heureux un geek en chasse de monstre.

les plus de ce portable :

la puissance, ça répond dans la seconde, je peux faire tourner des logiciels gourmands en ressources en même temps,
évolutif : il reste un emplacement pour 1 disque, et chaque composant est remplaçable, 3 barettes DDR3, vu le prix de la barrette de 4Go, c'est important,
l'écran, le 17", c'est agréable, en 1920x1200, il faut tout de même ajuster l'affichage pour grossir les icônes ou la police,

les moins :

le clavier aurait pu être plus grand et un peu plus bas, vu la place qu'il y a pour poser ses mains, et c'est un clavier...Belge donc certaines touches différent (\, [, ], ...),
dit puissance dit consommation, il faudra penser à la mise en veille, d'autant plus sous Windows 7 où la reprise est ultra rapide

J'ai installé VMWare server, avec une VM Windows Server 2008 R2 64 bits + Visual Studio 2010 B2, rapide, très rapide, important pour la veille.

...faut que je me retrouve les jeux maintenant.

NHModeler : DSL de génération de code à base d'Oslo / langage M, rien ne se perd, rien ne se crée, tout se transforme en info

zorky — Wed, 07 Oct 2009 22:15:00 +0200

Flex et Bison

Je me souviens dans ma jeunesse (il y a très peu de temps donc), dans la boite où j'ai commencé mon activité pro, on développait des services ~~de messageries roses~~ télématiques à 1,23 Frs /mn (voire le double en trichant un peu). Vous savez l'Internet français, qu'on appelait Minitel sur le réseau X25 de Transpac (CA du minitel en 2007 : 100 millions €, à peine imaginable)

Le moteur Opsion que nous utilisions générait du C, et il fallait donc écrire du C pour nos services. A l'époque, point de bases de données, mais des fichiers indexés au format C-ISAM. A chaque entité, il fallait écrire la génération de l'index, tout un tas de petites choses et surtout des fonctions de recherche sur la structure de données (à l'octet près...) (par catégorie, par nom, ...) en utilisant l'API C-ISAM, ce qui était assez fastidieux, et surtout courageux.

Comme on était de vrais geeks devant un écran noir à fonte verte, avec du vi, il nous fallait trouver un moyen pour automatiser toute cette phase de code plus ou moins toujours la même. J'avais alors créé une petite grammaire (qu'on appellerait DSL maintenant) à base de create table, afin de générer les fichiers C ad-hoc pour chaque table contenant les champs et index souhaités. Pour développer ce genre de programme, un compilateur en gros, nous utilisions le couple Lex & Yacc pour interpréter notre pseudo-langage (les create table avec les champs typés, et les index) afin de générer le code C pour utiliser l'API C-ISAM.

Mais pourquoi tu nous racontes ta p'tite vie de geek Olive ? tout simplement que lorsque vous utilisez NHibernate, la phase mapping, création des classes peut être très rapidement rébarbative. NHModeler se propose de résoudre tout ça, pour nous, informaticiens feignants : à partir d'une grammaire à base d'entités (le modèle), de générer une multitudes de fichiers : le modèle (les class C# de nos entités), les .hbm (le mapping), le fichier SQL de création des tables, fichiers qu'on aura plus qu'à intégrer à notre projet. Cette génération s'apparente à du MDA (Model Driven Architecture), avec ses inconvénients et ses avantages.

NHModeler

NHModeler a besoin du SDK Oslo. Également, afin de lancer la compilation de votre DSL, il manque 2 assembly dans les binaires fournis : log4net et les Iesi.Collections, les 2 pourront être pris de vos binaires NHibernate.

Comme toujours, on souhaite représenter la relation suivante :

une relation many-to-many dans le langage NHibernate.

On déclare cette relation dans le langage NHModeler, contenu d'un fichier nommé respassoc.nhm :

NHModel 
{
   Entity Responsable 
   {
    Nom: string(30)
    Prenom: string(30)
    Assocs->Responsables: Assoc *
    } IN Responsables
 
   Entity Assoc
   {
    Libelle: string(30)    
    Description: string
    Responsables<-Assocs: Responsable *
   } IN Assocs
}

note : si l'on ne souhaite pas de modifications en cascade entre les 2 entités, il suffit d'ajouter le mot clé weak derrière les relations :

Assocs->Responsables: Assoc * weak
Responsables<-Assocs: Responsable * weak

il reste à exécuter la génération de code, de notre fichier respassoc.nhm qui contient notre description précédente, pour le dialect SQL Server 2005 :

NHModeller.Console -a:Model  -d:MsSql2005 -ddl:dbscript.sql -out:"c:\temp\mymodel" respassoc.nhm

on obtient l'ensemble utile à NHibernate, les classes, hbm et le script SQL de création de tables

dans le script de création nous avons bien entendu les 3 tables qui représentent notre relation : Responsables, Assocs et la table de jointure Assoc_Responsable

CREATE TABLE Responsables (
   Id INT IDENTITY NOT NULL,
   Nom NVARCHAR(30) NOT NULL,
   Prenom NVARCHAR(30) NOT NULL,
   PRIMARY KEY (Id)
);
 
CREATE TABLE Assoc_Responsable (
   Responsable_Id INT NOT NULL,
   Assoc_Id INT NOT NULL,
   PRIMARY KEY (Assoc_Id, Responsable_Id)
);
 
CREATE TABLE Assocs (
   Id INT IDENTITY NOT NULL,
   Libelle NVARCHAR(30) NOT NULL,
   Description NVARCHAR(255) NOT NULL,
   PRIMARY KEY (Id)
);
ALTER TABLE Assoc_Responsable ADD constraint FKFF76651DD5384AF6 FOREIGN KEY (Assoc_Id) REFERENCES Assocs;
ALTER TABLE Assoc_Responsable ADD constraint FKFF76651D9647BEE3 FOREIGN KEY (Responsable_Id) REFERENCES Responsables;

et les *.hbm.xml :

<?xml version='1.0' ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="Model" namespace="Model">
	<class name="Responsable" table="Responsables">
		<id name="Id" column="Id" access="field.camelcase-underscore">
			<generator class="native" />
		</id>
		<property name="Nom" column="Nom" type="String" not-null="true" length="30" />
		<property name="Prenom" column="Prenom" type="String" not-null="true" length="30" />
		<set table="Assoc_Responsable" access="field.camelcase-underscore" name="Assocs" cascade="none">
			<key column="Responsable_Id" />
			<many-to-many class="Assoc" outer-join="true" column="Assoc_Id" />
		</set>
	</class>
</hibernate-mapping>
 
<?xml version='1.0' ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="Model" namespace="Model">
	<class name="Assoc" table="Assocs">
		<id name="Id" column="Id" access="field.camelcase-underscore">
			<generator class="native" />
		</id>
		<property name="Libelle" column="Libelle" type="String" not-null="true" length="30" />
		<property name="Description" column="Description" type="String" not-null="true" />
		<set table="Assoc_Responsable" access="field.camelcase-underscore" name="Responsables" cascade="none">
			<key column="Assoc_Id" />
			<many-to-many class="Responsable" outer-join="true" column="Responsable_Id" />
		</set>
	</class>
</hibernate-mapping>

La documentation est riche avec des exemples, le langage est assez complet et semble répondre aux principales fonctionnalités de NHibernate, ce projet vaut la peine de s'y arrêter, au moins pour se rappeller de bons souvenirs

Petit défaut : pas de sources disponibles.

Repository générique et IoC avec Castle Windsor

zorky — Mon, 05 Oct 2009 22:33:00 +0200

Repository générique

Lorsque l'on a à interroger plus d'une entité, il convient de factoriser son code afin d'en réduire le nombre de lignes (maintenance, évolution, ...).

Pour cela, on peut utiliser un repository générique qui consiste à factoriser les fonctions les plus communes, à savoir : Get, Delete, Save, GetAll, voire Find en utilisant une expression (lire ce billet sur les find). On peut alors représenter cela au travers d'une interface générique, socle qui sera à compléter pour des besoins plus spécifiques.

public interface IRepository<T>
{
        T GetById(int id);
        void Save(T entite);
        void Delete(T entite);
        List<T> GetAll();
        List<T> Find(Func<T, bool> expression);
}

ou mieux, si l'on souhaite un type generic pour l'ID de nos entités :

public interface IRepository<T,TId>
{
        T GetById(TId id);
        void Save(T entite);
        void Delete(T entite);
        List<T> GetAll();
        List<T> Find(Func<T, bool> expression);
}

[photo]

GetById est optionnel, le Find avec l'expression pourrait suffire pour retrouver une entité par son id : Find(x=>x.Id==4)

On a l'implémentation suivante, on utilise NHibernate comme ORM, cela reste valable avec d'autres :

public class Repository<T,TId> : IRepository<T,TId>
{
   public T GetById(TId id) {  return session.Get<T>(id); }   
 
   public void Save(T entite)
   {
      try {           
          session.BeginTransaction();
       session.SaveOrUpdate(entite);
       session.Transaction.Commit();
      } catch(Exception e)                    
           if(session.Transaction.IsActive)
         session.Transaction.Rollback();
      }
   }
 
   public void Delete(T entite)
   {
            try
            {
                session.BeginTransaction();
                session.Delete(entite);
                session.Transaction.Commit();     
            }
            catch (Exception e)
            {
                if (session.Transaction.IsActive)
                    session.Transaction.Rollback();
            }
        }
 
   public List<T> GetAll()
   {      
         return session.Linq<T>().ToList();
   }
 
   public List<T> Find(Func<T, bool> expression)
   {
     return session.Linq<T>().Where(expression).ToList();
   }
}

IoC

Pour chaque type d'entité, on peut alors se créer un repository en lui indiquant son type.

Pour cela, nous allons utiliser Castle Windsor, un framework IoC qui permet également d'instancier les types génériques. Mais au fait, Castle Windsor, ça sert à quoi en 2 mots exactement ? Ce framework nous permettra, au même titre qu'une factory, d'instancier un objet de type A qui implémente une interface, et ce, lorsque l'on lui demandera. Il permet également et surtout d'instancier des objets qui seront injectés (sous forme d'une propriété ou dans le constructeur) dans notre objet de type A : un objet DAL, de mails, de logging, ...et uniquement à base d'interface afin de découpler les objets entre eux. En gros, le conteneur IoC s'intercale entre la couche présentation (Web par exemple) et nos implémentations (services implémentant des interfaces).

Imaginons la relation suivante : des associations et des responsables

Pour avoir 2 repository, 1 pour chaque entité, dont Assoc qui aura une clé de type string, avec quelques opérations :

IRepository<Assoc, string> repoAssoc = IoC.Resolve<IRepository<Assoc, string>>();
IRepository<Responsable, int> repoResponsable = IoC.Resolve<IRepository<Responsable, int>>();
 
var myrepo = repoAssoc.Get("myassoc1");
var mylistrespons = repoResponsable.Find(a=>a.Prenom.StartsWith("oli"));
var resp = repoResponsable.Get(37);
resp.Nom="dudu";
repoResponsable.Save(resp);

IoC est une classe utilitaire qui encapsule l'appel Windsor (voir aussi ce billet sur le sujet) :

public static class IoC
{           
      private static IWindsorContainer _container = new WindsorContainer(new XmlInterpreter());
      public static T Resolve<T>() { return _container.Resolve<T>(); }
}

Configuration Castle Windsor

Au niveau configuration de Castle Windsor pour représenter les instanciations et les injections, le framework permet de déclarer le type des générics à l'aide du format suivant que cela soit pour le service (le contrat) et le type (l'implémentation) :

mynamespace.IInterface`N[[type1], [type2]{, [typeN]}]], assembly

ou N est le nombre de paramètres de notre générique ici T et TId, donc 2 (s'il il y avait eu que T on aurait 1, trop fort), type, le type à instancier pour les génériques, ici, nos entités Assoc et Responsable.

Pour Assoc, on aurait le repository Repository<Assoc,int>, l'implémentation de IRepository<T,TId> pour l'entité Assoc, qui sera représenté dans la configuration Windsor par (nos POCO / entités et interfaces sont dans l'assembly Connector, et les implémentations, dans l'assembly Impl) :

service="IRepository`2[[Connector.Assoc, Connector],[System.String]], Connector", type="Repository`2[[Connector.Assoc, Connector],[System.Int32]], Impl"

signifie : instancie moi Repository<Assoc, int> de l'assembly Impl, qui implémente IRepository<Assoc, int>, de l'assembly Connector.

Dans l'exemple, on injecte dans les composants RepositoryAssoc et RepositoryResponsable, un objet DALContainer, notre ORM. Le paramètre lifefestyle="transient" demande à Castle Windsor d'instancier à chaque fois nos objets, a contrario d'un singleton du comportement par défaut.

<?xml version="1.0"?>
<configuration>
    <components>
      <!-- container ORM -->
      <component id="DALContainer"
                   type="Impl.DALContainer, Impl"
                   service="Connector.IDALContainer, Connector">        
      </component>
 
      <!-- Repository Assoc -->
      <component id="RepositoryAssoc"
               service="Connector.IRepository`2[[Connector.Assoc, Connector],[System.String]], Connector"
               type="Impl.Repository`2[[Connector.Assoc, Connector],[System.String]], Impl"
               lifestyle="transient">
        <parameters>
          <container>${DALContainer}</container>
        </parameters>
      </component>
 
      <!-- Repository Responsable -->
      <component id="RepositoryResponsable"
               service="Connector.IRepository`2[[Connector.Responsable, Connector],[System.Int32]], Connector"
               type="Impl.Repository`2[[Connector.Responsable, Connector],[System.Int32]], Impl"
               lifestyle="transient">
        <parameters>
          <container>${DALContainer}</container>
        </parameters>
      </component>
    </components>
</configuration>

A base d'une configuration simple et d'un usage accessible, on aura le contrôle de nos repository pour interroger nos entités, Castle Windsor, mangez-en !