Je change de sujet par rapport aux précédents postes, et je m’attaque à un autre sujet épineux: la communication inter-processus.

Au début de ma vie professionnel, je n’ai pas commencé à travailler en .Net, mais en Delphi.

J’avoue que Delphi était séduisant. Avant .Net, c’était la manière la plus efficace de réaliser des applications Windows lourde avec un Designer d’interface unique. Et puis, n’oublions pas que l’inventeur du langage Delphi n’est autre que Anders Hejlsberg, qui fut embauché par Microsoft pour inventer C# !

Quand .Net prenait de plus en plus d’ampleur,  j’ai alors réussi à convaincre tout le monde de s’y mettre.
Mais comme la migration devait se faire petit à petit, il fallait intégrer Delphi avec .Net.

Pour cela, j’ai découvert COM.
COM est une technologie 100% Microsoft, mais qui se base sur les mêmes principes que Corba.
COM permet de communiquer entre les applications, peu importe le langage. La communication se faisait en activant des services, à l’aide d’un contrat qui se rédigeait dans un langage indépendant du langage de compilation : IDL (Interface Definition Language).

C’était magique : on pouvait inclure un UserControl .Net dans une application Delphi existante ! On pouvait aussi appeler des services .Net depuis Delphi, et vis vers ça !

Les services étaient d’ailleurs enregistrés auprès de Windows, dans la base de registre. Donc, quand un programme Delphi demande un service qui répond à une interface, Windows se charge de le localiser (DLL ou EXE) de l’héberger dans un conteneur (dans le cas de l’EXE, il lance ce dernier, dans le cas de la DLL, il l’host dans DLLHOST.exe) et d’instancier le service pour qu’il puisse être utilisé.

Et ce n’est pas tout ! Il y avait aussi DCOM qui est la version distribué de COM. Cela veut dire que si la DLL n’est pas sur la machine actuelle, Windows se charge d’interroger les autres serveurs DCOM pour qu’ils instancient le service à distance ! Tout cela avec une couche de sécurité ultra complexe !

De plus, le langage IDL supporte les méthodes, les propriétés, les événements, les paramètres de type « out », l’héritage d’interfaces, la gestion des versions, etc.…

Si vous souhaiter exposer des services sous Windows, cette technologie semble la plus appropriée.

Dans le monde des serveurs J2EE, ce fût Corba, concurrent direct à COM, qui remplissait ce rôle.

Mais voila : COM est 100% Windows, 100% Natif (non managé) ce qui rend le pont COM-.Net peu performant.

Concernant CORBA, il existe bien des connecteurs pour .Net, mais pas de serveur CORBA 100% managé.
De plus, CORBA est abandonné dans certains domaines à cause de sa lourdeur : les distributions Linux ont migré de CORBA à DBUS pour avoir aussi leur « équivalent à COM ». A noter que DBus existent en 100% .Net: http://www.ndesk.org/DBusSharp

Microsoft abandonne d’ailleurs COM pour sa technologie de communication phare : WCF.
Avant WCF, Microsoft avait introduit une autre solution 100% .Net: .Net Remoting. Mais ce dernier était trop simple et a fini par être abandonné, même si c’est toujours la technologie par défaut pour communiquer inter-AppDomain.

Alors, que choisir comme technologie de communication et d’activation de service ? Point à Point ou par un intermédiaire (Bus/Broker)? Quel format de message/marshalling doit-on utiliser?

Pour ma part: COM n’est pas multi-plateforme, je ne suis pas convaincu par l’usine à gaz WCF, DBusSharp est trop bugué, .Net remoting est trop simple/limité… je reste un sur ma fin.

Mais entre temps, j’ai découvert le “Messaging” et la communication asynchrone, qui est parfaite pour un environnement distribué. On ne peut pas remplacer le RPC par le Messaging dans tous les cas, mais il a falloir que j’exploite cette voie.

Cette simplicité n’est pas toujours positive, on peut même dire que Microsoft est “maudit” par ce fléau: rester attractif pour les développeurs débutants.

En général, cela donne des frameworks “sales” avec un fort couplage du code métier avec les interfaces, impossible à tester unitairement bien sûr.

Pour pouvoir découpler tout cela, on distingue 3 couches:

• L’interface, appelée “view” ou “presenter”, c’est le moyen d’afficher l’information
• La logique métier, appelée “model”, c’est ce que l’on va pouvoir tester à l’aide de tests unitaires
• Les actions ou commandes, qui représente une action de l’interface par l’utilisateur qui va déclencher un traitement

Mais quand on sépare les responsabilités en plusieurs objets, on se retrouve avec un nouveau problème : comment coupler les vues, contrôleurs, etc. ? Comment “broker” les actions ?

Il y a une solution à cela: l’IOC. On peut dire aussi que le Databinding en est une autre.
Si Microsoft avait un train de retard sur les Framework IOC, ils connaissaient néanmoins déjà le problème depuis un moment, puisqu’ils l’avaient en partie résolu dans CAB.
C’est donc sans surprise que Microsoft nous livre son framework d’IOC “officiel” basé sur l’existant de CAB : Unity.

A la sortie d’Unity, j’étais déjà tellement convaincu par Spring.net que je n’ai jamais adopté le framework de Microsoft. De plus, les alternatives OpenSources étaient  bien présentes: Castle Windsor, Ninject, Autofac, etc.

A noter que les framework tel que CAB/RCP rendent vos clients lourds “extensibles”, ce qui veut dire qu’un plugin va pouvoir greffer de “vues” dans l’interface, et s’abonner aux “commandes”: chose tout à fait faisable avec de l’IOC.

Mais les frameworks IOC ne font pas tout, et ne suffisent pas à fournir une véritable architecture MVC pour client lourd, même s’ils peuvent nous y aider (voir mon poste précédent).

Pour résoudre le fléau du couplage fort entre l’interface et le code métier, Microsoft a sortie quelque chose de révolutionnaire: WPF et Silverlight!
Avec la venue de WPF et Silverlight, la communauté .Net OpenSource a commencé à se pencher alors sur le problème du MVC pour les applications lourdes. Divers frameworks apparaissent alors, comme Prism: http://compositewpf.codeplex.com/

Mais le MVC, comme on le connait dans le monde Web, ne s’applique pas bien aux clients lourds, surtout si on veut exploiter le Databinding et les événements.

Très franchement, je ne me suis jamais vraiment passionné pour WPF/Prism/etc. mais je voyais bien que quelque chose de gros était en train de venir…
J’ai ensuite assisté aux Techdays 2010 et j’en ai profité pour me mettre à jours sur le sujet.
Les sessions étaient d’ailleurs très accès sur Silverlight/WPF mais aussi sur le nouveau modèle MVVM (Model-View-ViewModel), et avec une bonne dose d’Unity bien sûr…
J’ai alors été très agréablement surpris par ces présentations, surtout celle qui montre comment supprimer tout le « code behind » des interfaces XAML avec des ViewModel et des Commands.

Pour mieux comprendre de quoi je parle, aller voir vite le screencast ici!!!

Bref, je ne sais pas si vous me suivez, mais l’IOC, le RCP, le MVC, la gestion de plugins, tout ça c’est intimement lié !

Petit à petit, .Net rattrape le retard vis-à-vis d’Eclipse RCP !
On peut même dire que .Net a pris de l’avance avec Silverlight/WPF, puisque la rédaction des interfaces en XML n’est qu’au stade de proposition pour Eclipse 4: http://wiki.eclipse.org/images/a/ab/XWT.pdf

C’était le 6 Janvier 2005, j avais blogué à ce sujet: j’avais découvert qu’avec Mono, il était possible d’exécuter un même programme EXE sous Windows comme sous Linux ! J’en avais la larme à l’œil…

Ce qui m’a le plus impressionné c’était de voir qu’il était possible d’exécuter du Java dans .Net grâce à IKVM ! Cela marchait tellement bien qu’ils ont réussi à exécuter Eclipse sous .Net ! Mais ce n’était qu’expérimental à l’époque…

En découvrant .Net, j’ai tout de suite pris conscience du retard par rapport à Java, et j’ai alors voulu m’y atteler.
J’ai alors commencé à réaliser un framework « RCP » comme celui d’Eclipse, mais full .Net. Voici le résultat à l’époque :

On pouvait réaliser des plugins qui fournissent des vues qui s’encrent dans différents endroits, que ce soit dans la fenêtre principale ou dans un onglet d’édition.
J’en était plutôt fier, encore aujourd’hui… j’ai bien envie de le porter avec les technos modernes d’aujourd’hui…

C’est aussi à cette époque que j’ai découvert Spring, et au même titre Spring.Net, que j’ai utilisé dans mon entreprise pour réaliser, avec Romain, un framework MVC Winforms.

J’ai aussi découvert d’autres framework IOC, et par la même occasion CAB de Microsoft (Composite Application Bloc), mais sans en être convaincu.

A l’époque, on commençait à parler d’OSGI, mais je n’avais pas assez de connaissance dans le domaine

En conclusion, je restais sur ma fin avec .Net, et j’en étais même frustré. Mais j’ai toujours été convaincu que c’était aussi “une terre d’opportunités” et que je pouvais faire quelque chose…
L’IOC, le MVC pour client riche, RCP, OSGI… les idées émergeaient déjà, mais n’était pas matures.

Et comme des images sont souvent plus parlantes que de longs discours, voici un extrait de ce qui est possible de faire:

En terme de rédaction du test, cela donne ça:

Feature: Test with ASP.net
	In order to get test coverage of my ASP.Net Application
	As a developper
	I want to run an embeded ASP.Net server in my NUnit test

@selenium
Scenario: Say Hello to Michel
	Given I'm on the default page
	When I enter the name "Michel"
	And I click the "SayHello" button
	Then the message is "Hello Michel"

Grâce à Specflow, je peux donc rédiger mon scénario en anglais, très lisible par l’utilisateur qui va pouvoir ainsi exprimer son besoin.
Ces phrases sont ensuite couplées à des méthodes C# qui effectuent une partie du test. Exemple:

[When("I click the \"SayHello\" button")]
public void IClickTheSayHelloButton()
{
    selenium.Click("SayHelloButton");
    selenium.WaitForPageToLoad((1 * 60 * 1000).ToString());
}

On remarque ici que j’utilise Selenium pour simuler le scénario et effectuer un click sur un bouton de la page.

Petite astuce: le scénario est “tagué” @selenium. Grâce à ce tag, je peux indiquer qu’il faut initialiser Selenium à chaque début de scénario tagué ainsi.

[BeforeScenario("selenium")]
public void BeforeScenario()
{
    var firefoxPath = Path.GetFullPath(
        Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"..\..\..\Libs\Firefox\firefox.exe"));
    var selenium = new DefaultSelenium("localhost",
                                       4444,
                                       @"*firefox " + firefoxPath,
                                       "http://localhost:8123");
    ScenarioContext.Current["selenium"] = selenium;
    selenium.Start();
}

OK, je suis content avec ça, je peux maintenant rédiger des tests fonctionnels lisibles et les automatiser à l’aide de Selenium.
Mais cela ne me donne pas la couverture du code de mon application .Net qui se trouve hébergée sur un serveur IIS

Afin d’avoir la couverture du code de toute l’application, j’ai alors décider d’exécuter l’application ASP.Net à l’intérieur du processus du test unitaire!
Afin d’héberger l’application ASP.net, j’utilise pour cela la librairie de Mono: XSP.
Pour cela, quelques lignes de codes suffisent:

[BeforeTestRun]
public static void BeforeTestRun()
{
    const int port = 8123;
    string path = Path.GetFullPath(@"..\..\..\MyApp.Web");
    const string webServerFileName = "Mono.WebServer2.dll";

    string sourcePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, webServerFileName);
    string destinationPath = Path.Combine(Path.Combine(path, "bin"), webServerFileName);

    File.Copy(sourcePath, destinationPath, true);

    var websource = new XSPWebSource(IPAddress.Any, port);
    webAppServer = new ApplicationServer(websource);
    webAppServer.AddApplication("localhost", port, "/", path);
    webAppServer.Start(true);
}

[AfterTestRun]
public static void AfterTestRun()
{
    webAppServer.Stop();
}

Simple non?

Voila alors le résultat:

Afin de pouvoir tester par vous même, vous pouvez télécharger les sources depuis http://bitbucket.org/grozeille/testwithaspdotnet/src/, lancer le serveur Selenium à l’aide de “SeleniumServer.bat“, lancer les tests avec “Test.bat“, et voir le rapport de couverture de code avec Libs\PartCover .NET 2\PartCover.Browser.exe en ouvrant le fichier Coverage.Xml.
Ça, ça rox du poney!

• Comment fonctionne un HttpHandler?
• Pourquoi ne pas utiliser les UpdatePanels?
• A quoi sert un MembershipProvider et comment s’en servir?

Si ces questions vous paressent obscures et que vous êtes plutôt un développeur “glisser-déposer”, alors je vous propose de vous “glisser-déposer” sur un autre blog

Pour les autres, j’ai un aveu à vous faire: je viens de découvrir qu’il n’est pas possible d’afficher 2 pages ASP.Net en simultané si elles accèdent à la Session.

J’ai cru que j’étais sous l’effet d’une drogue… mais non, c’était bien vrai.
J’ai alors voulu en avoir le cœur net, et j’ai fouillé de nombreux forums… c’est la que j’ai découvert que d’autres l’on découvert après 5 ans d’expériences en ASP.Net!!!

Certes, on ouvre rarement 2 pages Web d’un même site, mais il est plus fréquent d’avoir 2 appelles Ajax en simultané.
C’est mon cas, car j’aime Ajax, j’aime le Web, et j’utilise une technique “Comet” appelé “Long Pooling”. Cela consiste à faire un appelle Ajax potentiellement infinie, qui va se terminé seulement si le serveur à quelque chose à nous dire. Cela permet d’avoir un système de notification très simple à implémenter.

Pour vulgariser, au lieu d’avoir ça:

Client: “Tu veux me dire quelque chose?”
Server: “Non”
Client: “Tu veux me dire quelque chose?”
Server: “Non”
Client: “Tu veux me dire quelque chose?”
Server: “Mais lâche moi sale client!!!”

En long polling ça donne ça:

Client: “Bon, tu me préviens si t’as un truc à me dire…”
Server: “…”
Server: “…”
Server: “…”
Server: “…”
Server: “… ouai, j’ai un truc pour toi, un nouveau message”
Client: “OK, je le traite, bon, tu me préviens si t’as un autre truc à me dire…”

Et sinon, en C# ça donne ça:

public string LongAjaxCall()
{
    string result = null

    while(result == null)
    {
        lock(this.notificationList)
        {
            if(notificationList.Count > 0)
            {
                result = new JavaScriptSerializer().Serialize(this.notificationList.ToArray());
                this.notificationList.Clear();
            }
        }
        if(result == null)
            Thread.Sleep(500);
    }
}

En général, le serveur n’a pas les mêmes choses à dire aux différents clients, c’est pourquoi on utilise la Session. Mais cette dernière est verrouillée par le long pooling, l’utilisateur ne sera alors pas en mesure d’ouvrir une nouvelle page si l’appelle Ajax ne se termine pas, ce qui est plutôt fâcheux.

Et Spring.Net dans tout ça?

J’utilise massivement Spring.net, pas seulement pour l’IOC, mais pour bien d’autres choses que ce merveilleux framework offre.
Dans le cadre d’une application Web, il est possible d’avoir un “scope” pour les instances des objets:

• application: un singleton pour toute l’application Web
• session: l’instance n’existe que dans le cadre d’une session ASP.Net
• request: l’instance n’existe pour pour la duré de la requête HTTP

J’utilise pas mal le scope “Session”, afin d’instancier des “contrôleurs” différents pour chaque utilisateurs. Je peux ainsi conserver un état à l’aide des membres de mes contrôleurs (ou conserver une connexion SQL, etc.).

Je vous propose alors de jeter un œil à mon exemple afin de comprendre mon problème: http://bitbucket.org/grozeille/testaspsessionmultithread/src
Cette solution contient un premier exemple “TestASPSessionMultithread.Bad” qui illustre mon problème.

L’exemple est simple:
Vous avez une première page “Default.aspx” qui permet d’ajouter une “string” à une liste à l’aide du button “add” qui effectuera un appelle Ajax.
Vous pouvez alors ensuite déclencher un “long pooling” à partir du boutton “long polling” qui va demander au serveur de renvoyer les nouveaux items.

Dans cet ordre, tout va bien. Par contre, si vous faite un “long pooling” en premier, le boutton “add” restera bloqué et il sera donc impossible d’ajouter un nouvel item.

De même, vous pouvez tester aussi la page “Other.aspx” qui simule un lourd traitement qui prend 5 secondes. Quand vous essayer d’ouvrir la page “Other” et que vous tentez de recharger la page “Default” en parallèle, cette dernière va attendre la fin du chargement de la page “Other”.

A noter aussi que j’affiche le “creation time” des différents contrôleurs. Puisque Spring.Net permet d’avoir du LazyLoad, on voit que le OtherController est créé après le DefaultController.

Si vous regardez le code en détail, vous pouvez voir que je gère les appelles Ajax à l’aide d’un HttpHandler custom.
Je pense que le code est suffisamment bien commenté pour le comprendre, et pour ceux qui ont la flemme de récupérer le source depuis BitBucket, voici l’extrait:

public class BadAjaxHttpHandler : IHttpHandler, IRequiresSessionState
{
    public void ProcessRequest(HttpContext context)
    {
        // get the name of the controller and the action from the URL
        var action = context.Request.Url.Segments[context.Request.Url.Segments.Length - 1];
        var controller = context.Request.Url.Segments[context.Request.Url.Segments.Length - 2]
            .Replace(".ajax", string.Empty)
            .Replace("/", string.Empty);

        // get the instance of the controller thanks to its name
        var instance = ContextRegistry.GetContext().GetObject(controller);

        // get the method of the controller thanks to reflection
        var method = instance.GetType().GetMethod(action, BindingFlags.Instance | BindingFlags.Public);
        var args = new List();
        foreach (var item in method.GetParameters())
        {
            args.Add(TypeDescriptor.GetConverter(item.ParameterType).ConvertFromString(context.Request.Params[item.Name]));
        }

        // invoke the method of the controller
        var result = method.Invoke(instance, args.ToArray());

        // return the JSON value of the method result
        context.Response.Write(new JavaScriptSerializer().Serialize(result));
        context.Response.StatusCode = 200;
        context.Response.End();

On remarque que pour accéder à la session nous avons ici besoin d’implémenter l’interface “IRequiresSessionState”, mais la aussi, comme c’est en lecture/écriture, cela verrouille la session le temps de la requête HTTP.

Comment résoudre le problème?

La solution est dans le projet “02-TestASPSessionMultithread.Good.Unsecured”.

Pourquoi “Unsecured” ? On verra ça plus tard.

La solution est simple, il suffit d’accéder à la Session en “lecture seule”.
En effet, il peut être problématique d’ajouter une même clé depuis 2 thread concurrents, mais une fois que la clé est créée, c’est à vous de gérer la concurrence de la valeur.

Exemple:

Session[“list”] = new List(); // problème de concurrence, donc session verrouillée

((List)Session[“list”]).Add(“toto”); // ce cas est une lecture seule de la session, mais à vous de gérer la concurrence pour la collection

Comme Spring.Net est en quelque sorte une “grosse collection d’instance”, et que Sprint.net utilise une seule clé “spring.object”, cela s’applique aussi

Par défaut, les pages sont en accès Write à la session. Pour changer cela, il faut ajouter une option dans l’ASPX:

<%@ Page EnableSessionState="ReadOnly"  %>

Il a fallut un petit changement dans le HttpHandler Ajax aussi:

public class AjaxHttpHandler : IHttpHandler, IReadOnlySessionState

Cette nouvelle interface “IReadOnlySessionState” parle d’elle même

Et voila! C’est tout! Ca marche, plus de problème de concurrence!
Enfin… non ce n’est pas tout, on a un petit problème, c’est que Sprint.net ne pourra plus jamais initialiser la session sans accès en écriture
Il faut donc trouver un “bootstrap” qui accède à la session en écriture juste le temps de créer le contexte Spring.Net.

L’astuce est donc de faire une redirection vers un HttpHandler particulier “SpringSessionHttpHandler” si la session est nouvelle. Il peut alors accèder à la session en écriture grâce à l’interface “IRequiresSessionState” pour initialiser le contexte et rediriger vers la page d’origine.

Ceci est fait lors du “OnLoad” car nos pages héritent de “SessionPage”.

public class SessionPage : Page
{
    protected override void OnLoad(EventArgs e)
    {
        // build the spring.net session
        if (Session.IsNewSession)
        Response.Redirect("SpringSessionHttpHandler?ReturnUrl=" + Server.UrlEncode(Request.Url.ToString()), true);

        base.OnLoad(e);
    }
}

Le code du HttpHandler est très simple: il force la création du contexte Spring dans la session, puis redirige sur la page d’origine qui elle a un accès en lecture seule sur la session.

public class BadAjaxHttpHandler : IHttpHandler, IRequiresSessionState
    {
        public void ProcessRequest(HttpContext context)
        {
            // get the name of the controller and the action from the URL
            var action = context.Request.Url.Segments[context.Request.Url.Segments.Length - 1];
            var controller = context.Request.Url.Segments[context.Request.Url.Segments.Length - 2]
                .Replace(".ajax", string.Empty)
                .Replace("/", string.Empty);

            // get the instance of the controller thanks to its name
            var instance = ContextRegistry.GetContext().GetObject(controller);

            // get the method of the controller thanks to reflection
            var method = instance.GetType().GetMethod(action, BindingFlags.Instance | BindingFlags.Public);
            var args = new List<object>();
            foreach (var item in method.GetParameters())
            {
                args.Add(TypeDescriptor.GetConverter(item.ParameterType).ConvertFromString(context.Request.Params[item.Name]));
            }

            // invoke the method of the controller
            var result = method.Invoke(instance, args.ToArray());

            // return the JSON value of the method result
            context.Response.Write(new JavaScriptSerializer().Serialize(result));
            context.Response.StatusCode = 200;
            context.Response.End();
        }

Mais quel astuce géniale! …mais pourquoi “Unsecured” ?

Vous pouvez remarquer que j’affiche l’ID de la session dans la page.
L’identifiant de session est stocké par défaut dans un cookie. J’ai tout de même changé le nom de ce dernier, car si je laisse la valeur par défaut, je risque d’avoir un conflit avec une autre application (erreur de débutant)

<sessionState cookieName="TestSession"/>

Normalement, le cookie est “sécurisé”, cad qu’il n’est pas accessible depuis du Javascript malicieux.
Mais bon, un cookie ça reste quand même pas super sécurisé.

Si vous voulez tester un vol de session, il vous suffit de copier/coller l’ID de la session dans un cookie d’un autre navigateur.

Comment faire alors pour sécuriser le tout? Vous avez pour cela différentes solutions:

• implémenter votre propre gestion d’ID de session avec <sessionState customProvider=”MonType”>, et vérifier l’identité à l’aide de critère comme l’IP du client
• coupler la session avec l’authentification

C’est cette dernière solution que je vais vous présenter, car c’est la plus simple.
L’authentification en ASP.Net se fait à l’aide du MembershipProvider, que vous pouvez implémenter vous même. Le framework .Net va alors gérer l’identité à l’aide d’un cookie aussi, mais ce dernier est beaucoup plus sécurisé et vous pouvez y faire confiance.
Je vais alors stocker dans la session la valeur du cookie d’authentification, et vérifier donc l’identité avant d’accéder à la session.

Vous pouvez vérifiez cela par vous même à l’aide du projet 03-TestASPSessionMultithread.Good.Secured
Si vous tentez de voler le cookie d’authentification pour l’utiliser sur un autre navigateur, vous serez alors déconnecté. Si vous tentez de voler le cookie de session, vous serez alors aussi déconnecté.

Les pages hérites alors de “SecuredSessionPage”, et vont alors vérifier le cookie de session dans le “OnLoad“:

// if the user tried to steal the session of another user
if (Page.Request.Cookies[FormsAuthentication.FormsCookieName] == null ||
    !Equals(Page.Request.Cookies[FormsAuthentication.FormsCookieName].Value, Session[FormsAuthentication.FormsCookieName]))
{
    this.Logout();
}

Je vous laisse ensuite découvrir l’implémentation de l’authentification, mais ce n’est pas le sujet de ce billet et il n’y a rien de plus classique.

Conclusion

Si comme moi vous utiliser Spring.net avec ASP.net et que vous avez des problèmes de lenteur, essayer cette astuce

Livrer une version sans la tester, c’est un peu comme jouer à la roulette russe.
C’est pourquoi depuis longtemps je pratique les tests unitaires avec NUnit.

Mes tests étant de plus en plus complexe, j’ai appris aussi à utiliser RhinoMocks afin de simuler les dépendances de l’objet du test.

J’ai toujours fournis des efforts dans les tests: alors POURQUOI je stress toujours autant avant de livrer une version?

Simple: car malgré les tests et une bonne couverture, je livre toujours des bugs.
Le fait est que, les tests unitaires valident chaque briques de manière indépendante, mais pas toute l’application dans son ensemble.
De plus, faisant beaucoup d’application Web, je me dois de tester l’interface HTML + Javascript, ce que je ne fais pas pour l’instant.

J’ai bien eu des tentatives avec Selenium, mais sans trop de résultat.
J’ai bien envisagé JSUnit, mais je n’y suis pas encore là.

Mais même si je test tout de manière indépendant, le plus gros des problèmes survient lors de l’intégration de toutes ces briques, avec par exemple des bugs dans les fichiers de configuration Spring.net.

Si Selenium me permet de tester cette intégration, j’ai tout de même un gros problème: je ne peux pas prédire les données de mon test, ce qui fait que parfois il passe, et parfois il ne passe pas.

J’ai aussi rencontré un autre problème avec les tests unitaire: la rédaction de ces derniers.
Quand je souhaite tester 2 scénarios différents, mais similaire à 90%, je me retrouve avec beaucoup de copier/coller.

Je factorise alors, mais mon test devient rapidement difficile à lire, alors que pourtant il peut servir de documentation du fonctionnement du code.

Après quelques recherches, et la lecture de l’excellent blog de Steve Sanderson, je me suis mis au BDD!

Le principe est de décrire un besoin utilisateur dans sa langue native: non, pas le C#… l’anglais!
Cela donne quelque chose comme:

Feature: Test SpecFlow with Selenium and RhinoMocks
In order to test Specflow
As a geek
I want to write stories with Specflow
And test the application with Selenium
And mock the backend with RhinoMocks

Le truc, c’est que cela va me servir de Spec, ce qui va donc orienter la conception de mon application.

C’est déjà l’objectif du TDD: concevoir une architecture à partir des tests, cela nous permet de réaliser QUE CE QUE L’ON A BESOIN: c’est le principe du KISS ou YAGNI.

Mais ces tests peuvent être difficile à concevoir, mais le BDD nous aide à décrire nos tests!
Si quelqu’un débarque sur le projet, et lit un test de 100 lignes de code, il va peut-être pas comprendre du premier coup. Mais s’il lit la version “Anglaise”, à moins qu’il ne sache pas lire, il va alors comprendre le test.

Cette magie se fait à l’aide de SpecFlow, qui est la version 100% .Net du très à la mode Cucumber (ou Cuke4Nuke).

Au programme: rédaction des tests “en Anglais”, intégration dans VisualStudio, et génération d’un test unitaire découpé en étapes (une étape par phrase).
Cela rend alors les tests unitaires vraiment TRES TRES lisibles.

Reprenons mon cas, ou je souhaite tester une application Web dans son ensemble.
Afin de tester l’interface Web, je vais implémenter les étapes de mon BDD à l’aide de Selenium.

OK, j’ai maintenant un test compréhensible par un utilisateur… J’ai un test NUnit C# correctement découpé et donc plus lisible par les développeurs. Je pars du test pour définir mon UI, qui elle même va orienter le design de mon Controller et ainsi de suite… Je simule les clicks de souris afin de naviguer dans le site, et je détecte les erreurs “d’intégration”…
Mais j’ai toujours un même problème: je ne maitrise pas les données de ma base afin de vérifier le fonctionnement de mon test.

Dans ce cas, il me faut simuler ma couche d’accès aux données à l’aide de mocks RhinoMocks.
Mais si mon test unitaire s’exécute sur un poste client, et que le site Web est hébergé sur un serveur dans un processus différent, comment puis-je faire mes mocks?

Grâce à Steve Sanderson, nous avons la solution, et elle s’appelle DELEPORTER.

Le principe est plutôt simple: un module HTTP agit comme un serveur .Net Remoting.
Le client sérialise un Delegate (anonyme ou pas, ou lamdba) afin de l’envoyer sur le serveur et de l’exécuter dans son processus.

C’est clairement une grosse faille de sécurité, alors pensez à bien ségréguer les configurations de tests et celles de production!

Etant donné que j’utilise Spring.net pour l’injection de dépendance, je peux injecter de Mocks à l’aide d’une petite factory RhinoMock.
Mon test va ensuite définir le comportement de ces derniers pour mon cas de test.

Au final, cela donne:

// J'utilise Deleporter pour exécuter ce code coté Serveur
Deleporter.Run(() =>
{
        // je demande à Spring.net d'obtenir le MockRepository de RhinoMock
	var mocks = ContextRegistry.GetContext().GetObject("MockRepository") as MockRepository;

        // je demande à Spring.net d'obtenir le mock déjà créé et injecté
	var repository = ContextRegistry.GetContext().GetObject("MyRepository") as IMyRepository;

        // j'informe RhinoMock que je souhaite recoder le comportement de mon mock
	mocks.BackToRecord(repository);

        // Quand "GetMessage" sera appelé, je souhaite retourner "Welcome Mathias"
	Expect.Call(repository.GetMessage())
                .Repeat.Any()
                .Return(string.Format("Welcome {0}!", userName));

        // j'informe à RhinoMock que j'ai terminé de spécifier le comportement du mock
	mocks.Replay(repository);
});

Il ne reste plus qu’à exécuter le test Selenium, vérifier les données de l’UI, et la boucle est bouclée!

Les sources de cet exemple sont disponibles sur mon BitBucket: https://bitbucket.org/grozeille/testspecflow.mvc

Donc voila, je suis de retour avec un cerveau presque lavé.
Et comme j’ai commencé une série, il fallait bien que le la termine

Dans l’épisode 4 je vous ai parlé de Spring Java, le serveur d’application.
Je vais maintenant vous parler de Gigaspaces, car j’y ai bossé un petit peu, et ça a changé ma façon de penser.

Pour commencer: MAIS C’EST QUOI GIGASPACES?

C’est plusieurs choses à la fois. Ce qui est drôle c’est que le terme à la mode en ce moment est “No-SQL” et Gigaspaces est cité comme faisant partie de la catégorie.

D’autres appellent ça un “Tuple Space” mais on parle plus souvent de “In-Memory Data Grid” ou “Distributed Caching”.

Et comme “distributed” rime souvent aujourd’hui avec “Cloud”, il y a la des mots clés bien commerciaux

Mais comme je sais que vous, lecteurs, vous n’êtes pas la pour acheter une licence, mais vous êtes plutôt des Geeks du code, je vais expliquer cela de manière plus “pratique”.

Gigaspace est un cache mémoire: c’est un serveur qui fournie comme service de stocker et lire des données de type “clé+valeur” en utilisant la mémoire du serveur.
Un cache est pratique dans diverses situations:

• Vous stockez en mémoire une donnée lu depuis une base de donnée, afin de la lire plus rapidement les prochaines fois
• Vous stockez en mémoire une donnée calculée, qui va être traité par un autre programme
• Vous stockez des “messages” afin de communiquer de manière asynchrone avec d’autres programmes

En général, quand on souhaite partager des données entre 2 programmes, on utilise une base de donnée. Mais quand cette donnée change souvent, ou vous avez besoin d’une lecture très rapide, il est préférable de la stocker dans une mémoire partagée.

L’inconvénient de la mémoire, c’est qu’elle est plus rare que l’espace disque. Gigaspaces permet d’avoir un “cluster” de serveurs, vous pouvez donc additionner la mémoire d’autant de serveur que vous voulez.

Un autre inconvénient c’est que la mémoire est volatile, et en cas de crash du serveur, cette dernière est perdue.
Gigaspaces permet d’avoir des nœuds “backup” dans le cluster, ce qui veut dire que la mémoire est répliquée sur un serveur de secours au cas ou le premier plante. Bien sûr, vous pouvez avoir autant de backup que vous voulez.

…OUAI, ET ALORS?

Si Gigaspaces fournit un service avec une très faible latence et met l’accent sur les performances, ce qui m’intéresse c’est l’aspect “Cluster”.

Sur cette architecture, il est possible de déployer un programme de tout type: le déploiement du ZIP se fait en 2 clicks sur tous les nœuds du cluster, avec une gestion d’activation Primary/Backup.

Que ce programme soit un cache ou un serveur Web, je trouve l’idée très séduisante: c’est la dessus que repose le Cloud Computing.

Bien évidement, si l’ont décide d’avoir plusieurs applications “Primaire” pour répartir la charge, ces dernières devront prendre en compte cet aspect dans l’architecture (communication entre nœuds primaires, mémoire partagée).

Il est aussi possible de basculer l’état actif/inactif d’un nœud en fonction d’une mesure de charge: si le serveur 1 manque de mémoire, l’application se désactive pour se re-activer sur le serveur 2.

Je voulais aussi parler d’un dernier truc sympathique concernant Gigaspaces: le point d’entré d’une application déployée n’est pas un EXE ou un JAR, mais un fichier XML Spring! Il n’est donc pas nécessaire de coder un Bootstrap qui va seulement charger ce fichier de configuration…

Vous avez peut-être compris ou je voulais en venir: je souhaite un serveur d’application .Net sur lequel on peut déployer une application facilement sans ce soucier de l’infrastructure: que ce soit un serveur Windows ou Linux, qu’il y ai 3 instances primaires ou 6 instances primaires avec 2 backups, que les services consommés soient locaux ou distant…

C’est alors que la lourdeur des framework J2EE a donné naissance à une alternative qui s’est voulu plus simple : Spring.

J’aime bien Spring, je pense que vous le savez déjà
C’est pour moi en quelque sorte l’équivalent de l’esprit d’ALT.Net, mais en Java.

Ce fut alors la mode des IOC, et de l’approche orienté POJO. Quand j’ai découvert cela, je me suis rendu compte à quel point le framework d’Eclipse RCP pouvait être compliqué…
La gestion de dépendance et de publication/consommation de service devenaient extrêmement simple.

La ou Spring n’était qu’un framework, « SpringSource DM Server » est, quand à lui, un vrai serveur J2EE mais avec une architecture complètement différente de ses concurrents : il est basé sur le même moteur OSGI qu’Eclipse !

L’installation de nouvelles applications vous semble pénible ? SpringSource DM Server offre un « AppStore » pour installer un nouveau service et ses dépendances en 2 cliques!

Pour ceux qui ont lu mon billet sur WebMatrix, la fonctionnalité n’est pas tout à fait la même que c’elle du produit Microsoft.Vous pouvez ici installer bien d’autres choses que des applications Web: des ESB, des serveurs Web (car oui, en Java, on a le choix entre Tomcat, Jetty et autres), etc.
Vous voulez installer un serveur de Messaging ? Installer ActiveMQ en quelques cliques : http://www.springsource.com/repository/app/bundle/version/detail?name=com.springsource.org.apache.activemq&version=5.3.0

Vous trouvez plus d’infos sur http://www.springsource.com/products/dmserver/repository

En plus de tout ces avantages, SpringSource DM Serveur offre un interface d’administration d’un pure merveille, j’en bave quand je vois que Microsoft reste attaché à sa MMC…
Et comme si ça ne suffisait pas, SpringSource ont racheté Hyperic qui est une appli Web de Monitoring applicatif, ce qui rend l’administration de votre serveur  encore plus professionnel.

Petite conclusion:

• l’IOC c’est cool, vive l’approche POJO
• OSGI c’est de la bombe. Cela permet aussi bien de gérer des plugins dans un IDE, que des middleware dans un serveur d’applications
• l’installation d’une plateforme applicative doit être simple et facile, autant que de lancer un Setup de EasyPHP ou de cliquer sur un lien d’un “AppStore”
• vive les interfaces Web d’administration, à mort la MMC

J’avais dit qu’il manquait un équivalent à EasyPhp pour .Net, et on m’a fait remarqué d’un “IIS Express” pointait le bout de son nez…
WebMatrix est donc un gros Setup qui t’installe sur ta machine un IIS Express, un base de donnée Express, et un IDE Express (et d’autres trucs Express).

Je n’ai pas encore eu le temps de tester tout ça, mais on voit déjà la grosse machine commerciale!
Le site Web est très bien fait, avec plein de mots à la mode: D.R.Y, MVC, TDD, une petite screenshot de NerdDinner, tout pour plaire

Il y a un gros effort sur l’aspect “Communauté”, on peut facilement installer une application Web, .Net/PHP/autres, en quelques clicks.
A noter aussi le gros effort sur la documentation, tutoriel et compagnie,  pour que tout le monde puisse “faire du Microsoft rapidement”.

J’ai l’air de ne pas aimé? Ça se voit?

Bon, premièrement, je suis sous Ubuntu à cet instant précis ou je vous écris.
Ensuite, les vidéos Silverlight ne fonctionnent pas: Moonlight crash sous Google Chrome, et sous Firefox la vidéo ne se lance pas.
Enfin, si vous faite joue joue avec WebMatrix, vous allez vouloir déployer ça quelque part…
Ça tombe bien, Microsoft recommande pleins de “Hosting partner” avec du Windows Server 2008 R2… et du SQLServer bien sûr.

Revenons à EasyPHP.
Avec EasyPHP, vous avez un vrai Apache (pas une version Express) avec un vrai MySQL (pas une version Express).
Il existe aussi bien sûr des “EasyPHP like” avec du PostgreSQL, tout est possible.
Vous pouvez ensuite héberger cela sur du Windows si vous voulez… ou du Linux.

Bon, c’est vrai, EasyPHP n’installe pas un IDE, il va falloir en trouver un gratuit.
Ca doit être plutôt rareun IDE gratuit, d’après ce que l’on voit sur le site de WebMatrix:
Je cite: “Cerise sur le gâteau, c’est entièrement gratuit.”

Allez, parce-que je suis gentil, voici 3 IDE PHP gratuit:

• http://www.phpide.de/
• http://www.php-editors.com/
• http://www.phpide.de/

Le gros + de WebMatrix, c’est quand même de pouvoir télécharger n’importe quel application Web (ASP.Net et PHP) en quelques clicks. La, j’avoue, rien à dire.

Je vous laisse maintenant apprécier  la grandeur commerciale de Microsoft, je pense qu’ils vont réussir leur coup avec WebMatrix.