Aujourd’hui j’aimerai vous présenter un acteur français, Clever Cloud, qui se positionne sur le même créneau, la plateforme “Cloud”, de type “PaaS” (Platform as a Service)proposant la possibilité de déployer vos applications (Play 1.2.x et Play 2, mais aussi Java + Maven, PHP, Node.js et bientôt Ruby) avec une base de données MySQL ou PostgreSQL associées.

Après avoir créé un compte gratuit, il vous faut configurer votre clé SSH.

Viens ensuite le moment de la création de votre application sur la plateforme de Clever-Cloud.

En vous connectant à votre espace, vous devez créer une application via le menu “Add an app +” de la barre de menu.

Renseignez ensuite les informations de votre application :


L’étape suivante vous propose de choisir parmis les différents environnements possible :


Dernière étape, une vérification des informations et une validation :


Une fois l’application créée, Clever-Cloud vous présente les informations du repository Git qu’il met à disposition :


De retour sur votre machine, dans une commande shell, créez votre application Play :

C:\Dev\workspace>play new playOnCleverCloud
~        _            _
~  _ __ | | __ _ _  _| |
~ | '_ \| |/ _' | || |_|
~ |  __/|_|\____|\__ (_)
~ |_|            |__/
~
~ play! 1.2.5, http://www.playframework.org
~
~ The new application will be created in C:\Dev\workspace\playOnCleverCloud
~ What is the application name? [playOnCleverCloud]
~
~ OK, the application is created.
~ Start it with : play run playOnCleverCloud
~ Have fun!
~

Gitifiez votre projet :

C:\Dev\workspace>cd playOnCleverCloud

C:\Dev\workspace\playOnCleverCloud>git init

C:\Dev\workspace\playOnCleverCloud>git add .

C:\Dev\workspace\playOnCleverCloud>git commit -m "initial commit'

Enfin ajouter un adresse remote à votre repo git local :

C:\Dev\workspace\playOnCleverCloud>git remote add origin git+ssh://git@push.clever-cloud.com/app_d7eba5c4-bf02-4368-8709-36d0a2fabb25.git

C:\Dev\workspace\playOnCleverCloud>git remote -v
origin  git+ssh://git@push.clever-cloud.com/app_d7eba5c4-bf02-4368-8709-36d0a2fabb25.git (fetch)
origin  git+ssh://git@push.clever-cloud.com/app_d7eba5c4-bf02-4368-8709-36d0a2fabb25.git (push)

C:\Dev\workspace\playOnCleverCloud>git push origin master

Un Hook Git vous affiche même un message :

...
remote: {"id":320,"message":"The application has successfully been queued for redeploy.","type":"success"}
...

De retour sur la console de Clever-Cloud, vous pouvez accéder à votre application via une url mise à disposition (ou bien configurer votre propre dns)


Enfin CleverCloud vous propose une interface pour voir les logs :


Vous pouvez aussi choisir un service de Base de données (MySQL ou PostgreSQL) :


Maintenant vous devez démarrer votre application

Et voilà votre application est déployée et en fonctionnement. Vous pouvez vous rendre à l’adresse que clever-cloud met à votre disposition (dans le panel “Domain Names”)

Bravo à Clever-Cloud pour leur interface simple et pratique d’emploi (et leur réactivité en cas de question)

© nicogiard pour NooCodeCommit, 2013. | Permalink | Pas de commentaire
Tags: CleverCloud, Play

Sur un projet Play!> 1.2.5 avec MySQL (InnoDB), j’ai souhaité réaliser un test fonctionnel, pourtant très simple (un model User, un controller et une classe de test du controller), et pourtant j’ai été confronté à l’erreur suivante :

A java.lang.RuntimeException has been caught, java.util.concurrent.ExecutionException: 
play.exceptions.JavaExecutionException: 
Try to read id on null object models.User (controllers.Application.index, line 11)

Visiblement, lors de l’exécution du tests fonctionnel, la couche Controller ne semblait pas trouver de résultat, alors que la couche de test en trouvait…

Je vais essayer de vous montrer ici mon analyse du problème et une solution pour le contourner.

Pour les plus flemmard, voici un zip du projet.

Avant toute chose, créons une base de données (et un utilisateur) sous MySQL :

$ mysql -u root -p
Enter password: 

mysql> CREATE DATABASE fixtureFail;
Query OK, 1 row affected (0.01 sec)

mysql> CREATE USER 'fixtureFail'@'%' IDENTIFIED BY 'fixtureFail';
Query OK, 0 rows affected (0.00 sec)

mysql> GRANT ALL ON fixtureFail.* TO 'fixtureFail'@'%' IDENTIFIED BY 'fixtureFail';
Query OK, 0 rows affected (0.07 sec)

Puis créons une application Play!> standard:

$ play new fixtureFail

Modifions quelque peut le fichier de configuration :
application.conf

# Dev
# ~~~~~
application.name=fixtureFail
application.mode=dev
application.secret=NarifLkF6ynvKppI0Rw36mxKpiEP9ThPeHKFPQ79tH9CPukWMuIVZZByHfHFcmIO
application.log=DEBUG
date.format=yyyy-MM-dd
attachments.path=data/attachments
db=mem
mail.smtp=mock

# Testing
# ~~~~~
%test.application.mode=dev
%test.jpa.ddl=update
%test.mail.smtp=mock
#%test.db.url=jdbc:h2:mem:play;MODE=MYSQL;LOCK_MODE=0
%test.db.url=jdbc:mysql://localhost/fixtureFail
%test.db.driver=com.mysql.jdbc.Driver
%test.db.user=fixtureFail
%test.db.pass=fixtureFail

Et codons ensuite les 3 classes qui nous interessent :

app.models.User

package models;

import play.db.jpa.Model;
import javax.persistence.Entity;

@Entity
public class User extends Model {
    public String username;
    public String email;
}

app.controllers.Application

package controllers;

import models.User;
import play.Logger;
import play.mvc.Controller;

public class Application extends Controller {
    public static void index() {
        User user = User.find("username=?", "nicogiard").first();
        Logger.debug("user from controller : %s", user.id);
        render();
    }
}

test.ApplicationTest

import models.User;
import org.junit.BeforeClass;
import org.junit.Test;
import play.Logger;
import play.mvc.Http.Response;
import play.test.Fixtures;
import play.test.FunctionalTest;

public class ApplicationTest extends FunctionalTest {

    @BeforeClass
    public static void before() {
        Logger.debug("~~~~~~~~~~~~~~~~~~~~~~~~");
        Fixtures.deleteAllModels();
        Fixtures.loadModels("initial-data.yml");

        User user = User.find("username=?", "nicogiard").first();
        Logger.debug("user from before : %s", user.id);
    }

    @Test
    public void testThatIndexPageWorks() {
        User user = User.find("username=?", "nicogiard").first();
        Logger.debug("user from test : %s", user.id);

        Response response = GET("/");
        assertIsOk(response);
        assertContentType("text/html", response);
        assertCharset("utf-8", response);
    }
}

Lançons ensuite les tests. Nous nous attendons à avoir un résultat (dans la console) proche de celui ci :

user from before : 1
user from test : 1
user from controller : 1

Mais pour une raison que je n’explique pas trop voilà le résultat obtenu :

$ play test
...
11:21:21,922 INFO  ~ Application 'fixtureFail' is now started !
11:21:29,287 DEBUG ~ ~~~~~~~~~~~~~~~~~~~~~~~~
11:21:29,791 DEBUG ~ user from before : 1
11:21:29,805 DEBUG ~ user from test : 1

Et le Test échoue lamentablement…

Alors qu’en base de données la donnée existe bien.

mysql> select * from User;
+----+---------------------+-----------+
| id | email               | username  |
+----+---------------------+-----------+
|  1 | nicogiard@gmail.com | nicogiard |
+----+---------------------+-----------+
1 row in set (0.00 sec)

Le problème semble être que deux transactions indépendantes sont en cours (une pour le test et une pour le controller) ou quelque chose du genre.

Je vous avoue que je n’ai pas encore eu beaucoup de temps pour fouiller dans le code source de Play!> pour chercher d’où cela peut venir, mais j’ai au moins une solution pour pallier au problème

Vous devez donc modifier le mode de chargement des données initiales dans votre test fonctionnel avec le code suivant :
test.ApplicationTest

...
    @BeforeClass
    public static void before() throws ExecutionException, InterruptedException {
        Logger.debug("~~~~~~~~~~~~~~~~~~~~~~~~");
        new Job() {
            @Override
            public void doJob() {
                Fixtures.deleteAllModels();
                Fixtures.loadModels("initial-data.yml");
            }

        }.now().get();

        User user = User.find("username=?", "nicogiard").first();
        Logger.debug("user from before : %s", user.id);
    }
...

En effet, le chargement au sein d’un Job semble contourner le problème et permettre d’exécuter le test et d’obtenir le résultat escompté.

$ play test
11:26:20,386 INFO  ~ Application 'fixtureFail' is now started !
11:26:26,574 DEBUG ~ ~~~~~~~~~~~~~~~~~~~~~~~~
11:26:27,120 DEBUG ~ user from before : 1
11:26:27,126 DEBUG ~ user from test : 1
11:26:27,141 DEBUG ~ user from controller : 1

Et maintenant le test passe

Si jamais l’un d’entre vous avait ne serait-ce qu’une idée, n’hésitez pas à partager avec nous !

© nicogiard pour NooCodeCommit, 2012. | Permalink | Pas de commentaire
Tags: Play

En effet, quoi de plus pénible qu’une application Play!> qui ne se relance pas en cas de restart d’un serveur.

Voilà donc le script shell que j’utilise sur mon serveur Ubuntu :
ex : /etc/init.d/play-monapplication

#!/bin/sh

# Path to play install folder
PLAY_HOME=/opt/play/play-1.2.5
PLAY=$PLAY_HOME/play

# User running the Play process
USER=playUser

# Path to the application
APPLICATION_PATH=/opt/monapplication

case "$1" in
    start)
        echo -n "Starting Play service: "
        rm -f ${APPLICATION_PATH}/server.pid
        su $USER -c "${PLAY} start ${APPLICATION_PATH} --%prod >/dev/null"
        RETVAL=$?

        if [ $RETVAL -eq 0 ]; then
            echo -n "Done\n"
        else
            echo -n "Something goes wrong...\n"
        fi
        ;;
    stop)
        echo -n "Shutting down Play service: "
        ${PLAY} stop ${APPLICATION_PATH} > /dev/null

        RETVAL=$?

        if [ $RETVAL -eq 0 ]; then
            echo -n "Done\n"
        else
            echo -n "Something goes wrong...\n"
        fi
        ;;
    status)
        ${PLAY} status ${APPLICATION_PATH}
        RETVAL=$?
        ;;
    *)
        echo "Usage: $SCRIPTNAME {start|stop|status}" >&2
        exit 1
        ;;
esac
exit 0

Ne pas oublier de rendre exécutable votre script :

sudo chmod +x /etc/init.d/play-monapplication


Ensuite on ajoute ce script au services de la machine

sudo update-rc.d play-monapplication defaults


ps : pour mémoire, pour supprimer un script des services

sudo update-rc.d -f play-monapplication remove


© nicogiard pour NooCodeCommit, 2012. | Permalink | Pas de commentaire
Tags: Play, Ubuntu

Après avoir pas mal cherché comment enlever cet icône (pas de clic droit / supprimer …) j’ai enfin trouvé comment faire! Voici la marche à suivre :
Menu Système / “Paramètres Système”

Cliquer sur le menu “Accès universel”

Dans l’onglet “Saisie”, décocher l’option “Activer les fonctionnalités d’accéssibilité à partir du clavier”

Et voilà l’icône a disparu.

© nicogiard pour NooCodeCommit, 2012. | Permalink | Pas de commentaire
Tags: Tips, Ubuntu

Et bien quand j’ai eu l’occasion d’essayer la plateforme Heroku, j’ai tout simplement halluciné !

Heroku est une plateforme dite “Cloud”, de type “PaaS” (Platform as a Service). Elle vous offre la possibilité de déployer vos applications (Java Servlet, Rails, Node.js mais aussi Play! Framework) avec une base de données PostgreSQL associées.

J’ai donc voulu voir si c’était vraiment utilisable. Après avoir ouvert un compte Gratuit chez Heroku, j’ai paramétré mes clés SSH comme il le fallait, j’ai ensuite essayer de livrer en production une application Play! Framework from scratch.

ps : n’est pas comptabilisé dans le temps, l’installation de Java et de Play! Framework, considérant que cela fait partie de mon environnement de travail.

Le mode opératoire est le suivant :

• Installation du Heroku Toolbelt
• Création d’un nouveau projet avec Play! Framework
• Connexion à Heroku
• Création de l’instance sur la plateforme heroku
• Git init -> add . -> commit
• Git push sur le repository mis à disposition par héroku
• Ouverture du navigateur

Résultat:

Début : 16:13:35
Fin : 16:18:20
Soit 04 Minutes 45 Secondes

En moins de 5 minutes vous avez une application Play Framework Up and Ready, accessible sur le Net, avec une base de données…

Voilà la trace de mon expérimentation pour les curieux

nicogiard@bespin:~/workspace$ date
lundi 25 juin 2012, 16:13:35 (UTC+0200)

nicogiard@bespin:~/workspace/playOnHeroku$ date
lundi 25 juin 2012, 16:18:20 (UTC+0200)


© nicogiard pour NooCodeCommit, 2012. | Permalink | 2 commentaires
Tags: Heroku, Play

Qui pourrait parfaitement représenter les Objets d’un Blog, mais pas que.

Imaginez que vous souhaitiez réaliser un API, compatible REST, qui vous permette de récupérer vos Posts et Comments au format JSon.

Nos Objets Métiers

Commençons tout d’abord par écrire nos objets Model :
app/models/Post.java

package models;

import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.OneToMany;
import play.data.validation.Required;
import play.db.jpa.Model;

@Entity
public class Post extends Model {
    @Required
    public String author;

    @Required
    public String title;

    @OneToMany(mappedBy = "post", cascade = CascadeType.ALL)
    public List<Comment> comments;
}

app/models/Comment.java

package models;

import javax.persistence.Entity;
import javax.persistence.Lob;
import javax.persistence.ManyToOne;
import play.data.validation.MaxSize;
import play.data.validation.Required;
import play.db.jpa.Model;

@Entity
public class Comment extends Model {
    @Required
    public String author;

    @Lob
    @Required
    @MaxSize(10000)
    public String content;

    @ManyToOne
    @Required
    public Post post;
}

Données de référence & Configuration

Pour nous simplifier la vie, Play! prévoit un mécanisme très pratique d’import de données, basé sur l’utilisation d’un fichier au format YAML
conf/initial-data.yml

Post(post1):
  author: moi
  title: Post 1
  
Post(post2):
  author: moi
  title: Post 2

Comment(c1):
  author: moi
  content: du Contenu
  post: post1

Comment(c2):
  author: moi
  content: du Contenu
  post: post1

Comment(c3):
  author: moi
  content: du Contenu
  post: post2

conf/application.conf

...
db=mem
...

Bootstrap Job & Controller

Le Bootstrap Job va nous permettre d’importer nos données de référence sans effort, et notre contrôleur devra réaliser notre besoin initial, à savoir nous retourner la liste des Posts
app/controllers/Bootstrap.java

package controllers;

import models.Post;
import play.jobs.Job;
import play.jobs.OnApplicationStart;
import play.test.Fixtures;

@OnApplicationStart
public class Bootstrap extends Job {
    public void doJob() {
        if (Post.count() == 0) {
            Fixtures.loadModels("initial-data.yml");
        }
    }
}

app/controllers/Application.java

package controllers;

import java.util.List;
import models.Post;
import play.mvc.Controller;

public class Application extends Controller {
    public static void index() {
        List<Post> posts = Post.findAll();
        renderJSON(posts);
    }
}

Premier résultat

Après avoir accédé via votre navigateur à l’adresse http://localhost:9000, vous devriez avoir l’erreur suivante :

Et dans votre console :

@67jf5njpa
Internal Server Error (500) for request GET /

Execution exception (In /app/controllers/Application.java around line 12)
IllegalStateException occured : circular reference error   Offending field: post    Offending object: preserveType: false, type: class models.Post, obj: Post[1]

Corrections

La méthode renderJSON prévoit l’utilisation de vos propre JSonSerializer. Ce que nous allons faire pour nos Objets Post et Comment.

app/models/serializer/PostJSonSerializer.java

package models.serializer;

import java.lang.reflect.Type;

import models.Post;

import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;

public class PostJSonSerializer implements JsonSerializer<Post> {
    public static PostJSonSerializer instance;

    private PostJSonSerializer() {
    }

    public static PostJSonSerializer get() {
        if (instance == null) {
            instance = new PostJSonSerializer();
        }
        return instance;
    }

    public JsonElement serialize(Post post, Type type, JsonSerializationContext jsonSerializationContext) {
        JsonObject obj = new JsonObject();
        obj.addProperty("author", post.author);
        obj.addProperty("title", post.title);
        obj.add("comments", jsonSerializationContext.serialize(post.comments));
        return obj;
    }
}

app/models/serializer/CommentJSonSerializer.java

package models.serializer;

import java.lang.reflect.Type;
import models.Comment;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;

public class CommentJSonSerializer implements JsonSerializer<Comment> {
    public static CommentJSonSerializer instance;

    private CommentJSonSerializer() {
    }

    public static CommentJSonSerializer get() {
        if (instance == null) {
            instance = new CommentJSonSerializer();
        }
        return instance;
    }

    public JsonElement serialize(Comment comment, Type type, JsonSerializationContext jsonSerializationContext) {
        JsonObject obj = new JsonObject();
        obj.addProperty("author", comment.author);
        obj.addProperty("content", comment.content);
        return obj;
    }
}

On modifie par la suite l’appel à la méthode renderJSon dans le fichier app/controllers/Application.java:

...
    public static void index() {
        List<Post> posts = Post.findAll();
        renderJSON(posts, PostJSonSerializer.get(), CommentJSonSerializer.get());
    }
...

Résultat final

Rafraîchissez l’adresse http://localhost:9000 pour obtenir le résultat suivant :

[
   {
      "author":"moi",
      "title":"Post 1",
      "comments":[
         {
            "author":"moi",
            "content":"du Contenu"
         },
         {
            "author":"moi",
            "content":"du Contenu"
         }
      ]
   },
   {
      "author":"moi",
      "title":"Post 2",
      "comments":[
         {
            "author":"moi",
            "content":"du Contenu"
         }
      ]
   }
]

ps: Je vous livre ici mes observations sur le fonctionnement des JSonSerializer. Si vous voyez une façon de mieux les écrire, ou de mieux faire n’hésitez pas à commenter ce billet.

© nicogiard pour NooCodeCommit, 2011. | Permalink | 4 commentaires
Tags: Play, Tips

app/controllers/Application.java

package controllers;

import play.mvc.After;
import play.mvc.Before;
import play.mvc.Controller;

public class Application extends Controller {

    @Before
    static void before() {
        System.out.println("before");
        renderArgs.put("nom", "Michel");
    }

    @After
    static void after() {
        System.out.println("after");
        renderArgs.put("nom", "Serge");
    }

    public static void index() {
        System.out.println("index");
        redirect();
    }
    public static void redirect() {
        System.out.println("redirect");
        renderArgs.put("nom", "Robert");
        render();
    }
}

Ainsi que le template associé :
app/views/Application/redirect.html

#{extends 'main.html' /}
#{set title:'Home' /}

${nom}

Lequel des trois prénoms suivants, Michel, Serge et Robert, va t’il s’afficher dans votre navigateur à l’adresse http://localhost:9000 ?

La réponse est Robert.

Conclusion : Un renderArgs.put dans un @After ne sert à rien!

© nicogiard pour NooCodeCommit, 2011. | Permalink | 5 commentaires
Tags: Play, Tips

Ce qui implique que vous ayez un répertoire app/view/Tags pour vos templates.

Ensuite imaginez que vous ayez besoin pour vos templates de créer des tags Play! personnalisés. Le framework s’attend à les avoir dans un répertoire nommé app/view/tags.

Vous commencez à voir où il pourrait y avoir un problème ?

Et oui, Play! sur Windows (qui est un système que je conchie) hérite du “case insensitive” de l’OS. Ce qui fait que pour lui, il n’y a pas de différence entre app/view/Tags et app/view/tags.
Play! sur Linux, qui lui est case sensitive, voit une différence, et donc ne trouve pas vos templates de tags placés dans le répertoire app/view/Tags.

En conclusion il faut donc faire attention à ne pas nommer un de vos contrôleurs Tags pour éviter tout problème avec les mécanismes internes du framework.

© nicogiard pour NooCodeCommit, 2011. | Permalink | 2 commentaires
Tags: Play, Tips

Ajouter à votre contrôleur la méthode @Before suivante :

public class MyController extends Controller {
    @Before
    static void basicAuth() {
        if (StringUtils.isBlank(request.user) && StringUtils.isBlank(request.password)) {
            unauthorized("Veuillez saisir vos identifiants");
        } else {
            User user = User.find("login=? and password=?", request.user, request.password).first();
            if (user == null) {
                unauthorized("Identifiants inconnus");
            }
        }
    }
    
    public static void index() {
        render();
    }
}

Ainsi, toutes les actions que vous appellerez dans ce contrôleur devront être authentifiées pour aboutir.

© nicogiard pour NooCodeCommit, 2011. | Permalink | Pas de commentaire
Tags: Play, Snippet

Venez nombreux le mardi 14 décembre à partir de 19h00 à l’eXia/CESI de Rouen/Mont Saint Aignan
Avec deux sujets phare du moment, le Normandy JUG termine l’année en beauté !

HTML5 & GIT

(...)
Lire la suite (244 mots)

© nicogiard pour NooCodeCommit, 2010. | Permalink | Pas de commentaire
Tags: News, NormandyJUG