Qu'est ce qu'on se fait ch ... !

Bon je sais le jeu de mots est des plus nazes douteux. Néanmoins, je vais tâcher d'expliquer le fonctionnement de mon dernier joujou dans mon réseau local et plus particulièrement avec mon os préféré debian ubuntu gnu/linux.

D'abord, voici l'engin :

Ce produit fonctionne très bien et s'intègre parfaitement dans un réseau via un port ethernet et boitiers CPL. Le protocole supporté est SAMBA. Avant toute chose, il convient de bien lire la doc relative à samba. Tout est dedans ! Cet article n'illustre que l'application avec le boitier WDTV.

Configuration du boitier en tant que disque dur réseau multimédia

Une fois installé un disque dur externe et le réseau activé, on peut accéder au boitier sans problème. Allez dans réseau et vous voyez apparaître l’icône suivante

Il ne reste plus qu'à faire des copies de fichier via nautilus ...

Configuration en tant que client

Je peux aussi accéder directement au contenu de mon pc sans avoir à faire de copie depuis ce dernier. Il suffit de configurer le PC en serveur samba.

Exécuter la commande suivante :

$apt-get install samba smbfs  system-config-samba

Après aller dans le menu suivant

Puis sélectionner les répertoires à partager:

Pour ne pas trop me prendre la tête, j'ai mis les partages en lecture pour tous. Pas besoin de renseigner un identifiant/mot de passe coté boitier WD. Ce dernier me met quand même une mire d'identification que je renseigne avec le compte anonymous. On peut configurer le partage par ce menu :

Et me voila avec un beau disque dur multimédia réseau parfaitement intégré dans mon réseau local ! :D

Remarques :

• On peut paramétrer le partage directement via le menu contextuel de nautilus
• Pour la partie serveur, on peut installer un serveur UPNP tel que mediatomb.

Dans le cadre de mon appli jsf sur gae, j'ai à interagir avec le service de calendrier google. Voici les actions que j'ai menées pour installer et faire fonctionner le bousin:

Installation du client GDATA dans le référentiel MAVEN

 $ mvn install:install-file -DgeneratePom=true -DgroupId=com.google.gdata -DartifactId=gdata-core
 -Dpackaging=jar -Dfile=gdata-core-1.0.jar -Dversion=1.0

$ mvn install:install-file -DgeneratePom=true -DgroupId=com.google.gdata -DartifactId=gdata-client
 -Dpackaging=jar -Dfile=gdata-client-1.0.jar -Dversion=1.0

 $ mvn install:install-file -DgeneratePom=true -DgroupId=com.google.gdata -DartifactId=gdata-calendar
 -Dpackaging=jar -Dfile=gdata-calendar-2.0.jar -Dversion=2.0

Ajout dans le fichier pom.xml

<dependency>
            <groupId>com.google.gdata</groupId>
            <artifactId>gdata-core</artifactId>
            <version>1.0</version>
        </dependency>
 
        <dependency>
            <groupId>com.google.gdata</groupId>
            <artifactId>gdata-client</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>com.google.gdata</groupId>
            <artifactId>gdata-calendar</artifactId>
            <version>2.0</version>
        </dependency>
        <dependency>
            <groupId>com.google.collections</groupId>
            <artifactId>google-collections</artifactId>
            <version>1.0</version>
        </dependency>

Identification

La partie la plus subtile. Trois choix sont possibles, une authentification par token, par login/password et par openid. J'ai choisi de gérer le token car mon application va utiliser la gestion des comptes google.

J'ai choisi de créer une servlet qui fait les actions suivantes : Proposer une page qui redirige vers la connexion google, récupération du token et stockage en base pour chaque utilisateur.

protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String tokenParameter = req.getParameter("token");
        if (tokenParameter == null) {
            req.getRequestDispatcher("/faces/retreiveToken.xhtml").forward(req, resp);
        } else {
            try {
//procedure google pour recuperer le token et le rendre permanent
                String onetimeUseToken = AuthSubUtil.getTokenFromReply(req.getQueryString());
                String sessionToken = AuthSubUtil.exchangeForSessionToken(onetimeUseToken, null);
                Logger.getLogger(TokenServlet.class.getName()).log(Level.INFO, "Token recupéré");
 
                UserManagedBean userManagedBean = (UserManagedBean) req.getSession(false).getAttribute("userManagedBean");
//assignation du token
                User user = userManagedBean.getUser(req);
                user.setToken(sessionToken);
//persistence
                BusinessService<User> userService = new BusinessServiceImpl<User>();
                userService.update(user, user.getId());
            } catch (GeneralSecurityException ex) {
                Logger.getLogger(TokenServlet.class.getName()).log(Level.SEVERE, null, ex);
            } catch (AuthenticationException ex) {
                Logger.getLogger(TokenServlet.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }

La page de connexion est assez simple :

<ui:composition template="./standardtpl.xhtml">
            <ui:define name="content">
                <h:form prependId="false">
                    <p>MyApp needs access to your
                        Google Calendar account to read your Calendar feed. To authorize
                        MyApp to access your account,
                        <a href="#{userManagedBean.requestUrl}">Connexion sur google</a>
                    </p>
                </h:form>
            </ui:define>
        </ui:composition>

Le lien de connexion se crée de la manière suivante

public String getRequestUrl() {
        StringBuffer request = new StringBuffer(FacesContext.getCurrentInstance().getExternalContext().getRequestScheme()).append("://").append(FacesContext.getCurrentInstance().getExternalContext().getRequestServerName()).append(":").append(FacesContext.getCurrentInstance().getExternalContext().getRequestServerPort()).append("/tokenServlet");
        return AuthSubUtil.getRequestUrl(request.toString(),
                "http://www.google.com/calendar/feeds/",
                false,
                true);
 
    }

Conclusion

Je m'arrêterai la dans les exemples car la documentation est déjà bien détaillée sur ce sujet. Quoi qu'il en soit, je trouve que chez google, a défaut d'oeuvrer pour les données privées de ses utilisateurs, il savent très bien faire des API et les documenter

Seule limitation, la possibilité de faire des tests unitaires avec le token. La gestion du retour avec un proxy n'est pas possible (menfin à ce que j'ai vu ...)

Après la mise à jour des différents composants ( GAE #1.3.5 , primefaces 2.1RC1, ...) me voila reparti à re-développer une appli sur GAE. Après quelques galères tests unitaires, j'ai pu me rendre compte des nombreuses limitations à JPA / GAE.

Les requêtes

D'abord, seul JPA V1 est implémenté. Ça a l'air con comme ca, mais par exemple on ne peut pas utiliser les CriteriaQuery alors que l'API JDO fournie par Google fournit les Filter.Après , me direz vous, c'est pas l'extase, ca ne fait pas exactement la même chose, on peut coder directement les critères en JPQL. Mais voila dès que vous voulez faire des recherches un peu larges avec par exemple un formulaire de recherche à critères multiples, vous pouvez obtenir l'erreur suivante :

testcase: testFindLike(info.touret.mycellar.test.BottleTest):        Caused an ERROR
Problem with query <SELECT A FROM info.touret.winecellar.pojo.Bottle A WHERE A.name like 'BOUTEILLE%'  or A.vintage like '2001%'>: Or filters cannot be applied to multiple properties (found both name and vintage).
org.datanucleus.store.appengine.query.DatastoreQuery$UnsupportedDatastoreFeatureException: Problem with query <SELECT A FROM info.touret.winecellar.pojo.Bottle A WHERE A.name like 'BOUTEILLE%'  or A.vintage like '2001%'>: Or filters cannot be applied to multiple properties (found both name and vintage).
        at org.datanucleus.store.appengine.query.DatastoreQuery.addLeftPrimaryOrExpression(DatastoreQuery.java:1131)
        at org.datanucleus.store.appengine.query.DatastoreQuery.addLeftPrimaryExpression(DatastoreQuery.java:1105)
        at org.datanucleus.store.appengine.query.DatastoreQuery.addPrefix(DatastoreQuery.java:931)
        at org.datanucleus.store.appengine.query.DatastoreQuery.handleMatchesOperation(DatastoreQuery.java:891)
        at org.datanucleus.store.appengine.query.DatastoreQuery.addExpression(DatastoreQuery.java:864)
        at org.datanucleus.store.appengine.query.DatastoreQuery.addExpression(DatastoreQuery.java:835)

Un peu bête ...

Les jointures et fetching

Sur ce sujet, je me suis arraché les cheveux pas mal de temps. Exemple : ne Jointure OneToMany ne me ramenait pas du tout les entités en question lors d'un select. Que faire ?? Après quelques recherches sur la toile, je me suis rendu à l'évidence, que GAE ne gérait que les jointures via les clés primaires. Oubliez les belles jointures bi directionnelles et uni directionnelles JPA . L'insertion , la modification ne peut s'effectuer que par les clés primaires

Exemple avec une relation onetoone

@OneToOne(cascade = {CascadeType.REFRESH})
    private Key producer;

Mais il est possible de "hacker" la matrice en rajoutant un autre attribut à notre classe qui aurait la configuration suivante :

@OneToOne(cascade = {CascadeType.REFRESH})
    @Column(name = "producer", insertable = false, updatable = false)
    private Producer producerAlias;

Donc pour les insertions, suppressions, nous sommes obligés de passer par l'instance de la classe Key, par contre, une sélection passerait par l'alias. Cette manipulation permet de gérer la jointure ( avec fetch !) directement au niveau de la requête JPQL.

Exemple :

Query query = em.createQuery("select from Bottle b join b.producerAlias");

C'est un peu biaisé, mais bon ca simplifie la vie au niveau des requêtes.

Après, ce n'est que mon avis, je me suis trouvé pas mal obligé de dé-normaliser mes relations entre entités. Par exemple, je me suis mis dans l'idée de faire un nuage de tags. Bien au lieu de créer un pojo tag qui serai persisté directement dans big table, j'ai préféré créer un attribut tagline pour mon entité maître. Ca m'a pris moins de temps à créer. après va falloir que j'optimise les requêtes par une gestion de cache par exemple.

Conclusion :

Quand on développe sur GAE, il faut à mon avis bien penser aux contraintes de cette plateforme, surtout sur la persistance des données. Le développeur JAVAEE habitué à hibernate/jpa peut vite pédaler dans la choucroute au début. A mon avis ( et pas que ) JDO est à préférer. l'API semble connaître moins de limites.

Pas mal de plaintes on été faite à ce sujet. Je viens de voir un article sur une recherche full text. A voir ...

A l'instar de mon autre ordinateur, j'ai mis à jour le netbook asus eeepc 1000h qui avait Karmic vers Lucid.

Comme ma dernière maj, tout s'est bien passé. Voici le résumé de la configuration avec l'état pour chaque composant :

Pour info, voici le résultat de la commande dmesg.

Retour sur GWT

Après quelques semaines sur GWT, je me suis vite lassé. Si on n'a pas d'éediteur graphique digne de ce nom ou une librairie intéressante de widget,on perd pas mal de temps à réaliser des applications dignes de ce nom ( à moins de s'appeler google biensûr...) Je suis donc revenu aux fondamentaux et me voila revenu sur JSF. J'en ai profité pour tester la version 2.0 sur Google App Engine. Et la c'est le drâme. C'est un vrai parcours du combattant ou un champ de mines, à vous de voir.

Problèmes rencontrés

Pas mal de problèmes que j'ai eu ont été résolus en me référant sur ce tutoriel ou sur cette page chez google

Pour faire simple, voici un résumé des problèmes

• La version 1.3.2 de l'appengine ne fonctionnait pas chez moi avec netbeans Obligé de passer en 1.3.1
• L'implémentation standard de JSF2 n'est pas supporté par défaut dans GAE car elle utilise la classe InitialContext qui n'est pas supportée.
• Il y a pas mal de paramètres à ajouter dans le web.xml ( cf ci-après )
• Pas de page de debug de facelets car nous sommes obligé de travailler dans un mode différent de DEVELOPMENT
• Le scope VIEW n'est pas "trop" supporté
• Problème XALAN ( voir après)

Dépendances à ajouter

Commons-logging

Petite dépendance nécessaire et qui n'apparaît qu'à l'éxecution

log4j

Idem

facestrace

Très utile pour le debug. De plus ce composant est bien intégré à primefaces. Il suffit d'ajouter le paramètre de requête HTTP trace=true pour que la console facestrace apparaisse.

xalan

Si comme moi vous avez l'erreur suivante

    com.sun.faces.config.ConfigurationException: CONFIGURATION FAILED! 
    com.sun.org.apache.xalan.internal.xsltc.runtime.BasisLibrary is a restricted class. Please see the Google App 
    Engine developer's guide for more details.

Vous devez ajouter les librairies serializer.jar et xalan.jar provenant du projet xalan dans le répertoire WEB-INF/lib de votre webapp.

Ma Configuration

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
    <display-name>
        wine cellar
    </display-name>
    <description>
        wine cellar
    </description>
    <!-- ***** GAE 1.3.0 appears to handle server-side state saving. *****  -->
    <context-param>
        <param-name>javax.faces.STATE_SAVING_METHOD</param-name>
        <param-value>client</param-value>
    </context-param>
    <context-param>
        <param-name>javax.faces.PROJECT_STAGE</param-name>
        <param-value>Production</param-value>
    </context-param>
    <context-param>
        <param-name>javax.faces.DEFAULT_SUFFIX</param-name>
        <param-value>.xhtml</param-value>
    </context-param>
    <context-param>
        <param-name>com.sun.faces.expressionFactory</param-name>
        <param-value>com.sun.el.ExpressionFactoryImpl</param-value>
    </context-param>
    <context-param>
        <description>
            Set this flag to true if you want the JavaServer Faces
            Reference Implementation to validate the XML in your
            faces-config.xml resources against the DTD. Default
            value is false.
        </description>
        <param-name>com.sun.faces.validateXml</param-name>
        <param-value>true</param-value>
    </context-param>
    <!-- ***** Accommodate Single-Threaded Requirement of Google AppEngine  -->
    <context-param>
        <description>
            When enabled, the runtime initialization and default ResourceHandler
            implementation will use threads to perform their functions. Set this
            value to false if threads aren't desired (as in the case of running
            within the Google Application Engine).
 
            Note that when this option is disabled, the ResourceHandler will not
            pick up new versions of resources when ProjectStage is development.
        </description>
        <param-name>com.sun.faces.enableThreading</param-name>
        <param-value>false</param-value>
    </context-param>
    <!-- primefaces -->
    <context-param>
        <param-name>com.sun.faces.allowTextChildren</param-name>
        <param-value>true</param-value>
    </context-param>
    <!-- Faces Servlet -->
    <context-param>
        <param-name>com.sun.faces.enableMultiThreadedStartup</param-name>
        <param-value>false</param-value>
    </context-param>
    <servlet>
        <servlet-name>Faces Servlet</servlet-name>
        <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet>
        <servlet-name>Resource Servlet</servlet-name>
        <servlet-class>
            org.primefaces.resource.ResourceServlet
        </servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>Resource Servlet</servlet-name>
        <url-pattern>/primefaces_resource/*</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>Faces Servlet</servlet-name>
        <url-pattern>/faces/*</url-pattern>
        <url-pattern>*.jsf</url-pattern>
    </servlet-mapping>
    <session-config>
        <session-timeout>30</session-timeout>
    </session-config>
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
        <welcome-file>index.xhtml</welcome-file>
        <welcome-file>index.html</welcome-file>
    </welcome-file-list>
</web-app>

Le fichier faces-config.xml

<faces-config version="2.0"
    xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-facesconfig_2_0.xsd">
<application>
    <locale-config>
      <default-locale>en</default-locale>
    </locale-config>
  </application>
 
    <managed-bean>
...
    </managed-bean>
 
</faces-config>

Limitations

Et oui il y a des limitations à tout ça : L'un des gros plus de la spec JSF2 est la scope view qui permet de conserver l'état d'un composant au sein d'une page dans n'importe quelle étape du cycle de vie JSF. Bref, c'est entre le scope session et le scope request. GAE ne semble pas trop le supporter. Il est même préférable de n'utiliser que le scope request. Personnellement j'ai du adapter mon design à un mode réellement sans état. GAE ne supporte pas le PROJECT_STAGE Development Il faut donc le paramétrer tel quel

<context-param>
        <param-name>javax.faces.PROJECT_STAGE</param-name>
        <param-value>Production</param-value>
    </context-param>

Cette configuration semble occulter la page d'erreur standard de facelets qui est très utile pendant le développement. Heureusement facestrace est la.

Enfin, l'une des grosses limitations est la suppression des données entre chaque arrêt/relance du SDK GAE. Je n'ai pas encore cherché trouvé comment les garder en mémoire.

Conclusion

A cette armé mexicaine de composants, il ne me manque qu'une solution d'IoC ( probablement CDI ) et surement un framework d' AOP. GAE fournit déjà pas mal de composants permettant de gérer les objets en mémoire et d'améliorer les perfs.

La suite dans un prochain numéro...