Monitoring des jobs Play avec CRaSH

Si vous cherchez un moyen simple de monitorer des jobs Play (1.2.5), vous pouvez utilisez
CRaSH et en ligne de commande, il vous suffit de saisir :

% dashboard | thread ls -n "jobs-thread*"

Plus d'informations sur http://www.crashub.org/

Premier pas avec le cloud Open Shift de Red Hat

Mon objectif : Deployer une application Play 1.2.5 sur OpenShift.

Pour cela, j'ai utilisé le lien suivant : planet_jboss

Résumé des étapes :

- Création de mon application :

J'ai crée directement une application JBoss 7 sur le site.Toutes les commandes pour cloner et se connecter
en ssh sont présentes.Il y a juste à faire un copier-coller.

- Installation sur Gentoo :

emerge dev-ruby/rubygems
ruby -e 'puts "Welcome to Ruby"
gem install rhc

- Initialisation (en tant que user)

rhc setup

- On clone le repo de notre application sur redhat

git clone ssh://XXX/~/git/monapp.git/

Ensuite j'ai suivi les étapes du lien ICI

- Export du war dans monapp/deployements :

play war -o /home/toto/monapp/deployments/cookies.war
git add deployments/cookies.war*
git push

- Vérification du déploiement

- Connexion en ssh sur le le cloud de redhat
- tail -f jbossas-7/logs/server.log

Remarque :

- J'ai essayé d'utiliser le cloud en entreprise.Je n'ai pas réussi en raison de proxy et de firewall.
J'ai essayé de me connecter en ssh par le port 80 mais sans succès.
- De chez moi, je n'ai rencontré aucun soucis et rapidement j'ai pu déployer une application sur le cloud de RedHat.

JavaFx et Maven exemple

Pour apprendre JavaFx, j'ai commencé un petit projet sur GitHub.
J'utilise JavaFx 2 et Maven. Peut être cela peut vous aider à démarrer vos propre projets.

Pour plus d'info : https://github.com/drieu/MetricViewer

sbt.ResolveException: download failed: org.slf4j#slf4j-api;1.6.6

Problème

Lorsque que j'exécutais la commande play run, j'avais l'erreur suivante :

[error] (*:update) sbt.ResolveException: download failed: org.slf4j#slf4j-api;1.6.6!slf4j-api.jar
[warn] some of the dependencies were not recompiled properly, so classloader is not avaialable

Solution

vi ./project/plugins.sbt

Il faut modifier le fichier en ajoutant la dernière version de play (2.1.0) :

// Comment to get more information during initialization
logLevel := Level.Warn

// The Typesafe repository
resolvers += "Typesafe repository" at "http://repo.typesafe.com/typesafe/releases/"

// Use the Play sbt plugin for Play projects
addSbtPlugin("play" % "sbt-plugin" % "2.1.0")

Ensuite vous pouvez redémarrer play run

Fermeture de KnowledgeBlackBelt

Mauvaise nouvelle !
Le site KnowledgeBlackBelt va fermer le 31 janvier 2013.
Pour info, le contenu est accessible gratuitement.

play 2.1 : Create yout first projetc with IntelliJ Tips

Pour créer un projet avec Play, c'est très facile :

$ play new my-app 
$ cd my-app 
$ play idea

Par contre, j'ai eu quelques difficultés avec la manière d'importer le projet dans IntelliJ. Dans la documentation, il parle d'import de modules mais dans mon cas, cela ne fonctionner pas bien ...

Donc, contrairement à ce qui est marqué dans la documentation, une fois que j'ai crée le projet et que je l'ai initialisé pour Play, je fais juste  :  File --> Open

Cela me créer mon projet correctement :-)

java 8 : Interfaces fonctionnelles

Dans cette article, nous allons aborder la notion des interfaces fonctionnelles. C'est le point d'entrée pour utiliser les nouvelles features de JAVA 8.

Definition de la JSR 335

A functional interface is an interface that has just one abstract method, and thus represents a single function contract. (In some cases, this "single" method may take the form of multiple abstract methods with override-equivalent signatures (8.4.2) inherited from superinterfaces; in this case, the inherited methods logically represent a single method.)

In addition to the usual process of creating an interface instance by declaring and instantiating a class, instances of functional interfaces can be created with lambda expressions, method references, or constructor references.
The function descriptor of a functional interface I is a method type—type parameters, formal parameter types, return types, and thrown types—that can be used to legally override the abstract method(s) of I.

Pour faire court, une interface fonctionnelle n'est rien d'autre qu'une interface avec une méthode abstraite.

Exemple simple :

Voici un exemple simple :

ICode.java

 package fr.dr.practice;

/**
 * Interface with just one abstract method.
 */
public interface ICode {
    String generate(int codeNumber);
}

Main.java

package fr.dr.practice;

/**
 * Created with IntelliJ IDEA.
 */
public class Main {

    public static String generateTmpCode(int newCode) {
        ICode code = new ICode() {
            @Override
            public String generate(int codeNumber) {
                return "MAIN_" + codeNumber + Math.random();
            }
        };
        return code.generate(newCode);
    }

    public static String generateTmpCodeWithLambda(int newCode) {
        ICode icode = codeNumber -> "MAIN_" + codeNumber + Math.random();
        return icode.generate(newCode);
    }

    public static void main(String[] args) {
        System.out.println(Main.generateTmpCode(12));
        System.out.println(Main.generateTmpCodeWithLambda(12));

    }
}

Un peu plus dur ...

La JSR nous dit que dans certains cas, on peut définir plusieurs méthodes qui représente une seule méthode :

In some cases, this "single" method may take the form of multiple abstract methods with override-equivalent signatures (8.4.2) inherited from superinterfaces; in this case, the inherited methods logically represent a single method.

Nous pouvons donc faire le cas suivant car equals() est public dans la classe Object :

public interface ICode {

    String generate(int codeNumber);
    boolean equals(Object obj);
}

Cependant, il n'est pas possible d'utiliser la méthode clone() (protected Object clone() throws CloneNotSupportedException {) car elle n'est pas public dans la classe Object :

public interface ICode {

    String generate(int codeNumber);
    Object clone();
   
}

Function descriptor 

La JSR 335 ajoute aussi le concept de Functional descriptor.
Voici un exemple de la JSR pour comprendre cette notion :

interface X { void m() throws IOException; }
interface Y { void m() throws EOFException; }
interface Z { void m() throws ClassNotFoundException; }
interface XY extends X, Y {}
interface XYZ extends X, Y, Z {}

// XY has descriptor ()->void throws EOFException
// XYZ has descriptor ()->void (throws nothing)

Conclusion

Les interfaces fonctionnelles vont permettre d'utiliser les lambda et d'autres JAVA 8 features.
 Il existe déjà des interfaces fonctionnelles dans le package java.util (e.g java.util.Comparator ). Java 8 a aussi un nouveau package : java.util.functions qui définit de nouvelles interfaces fonctionnelles. Si vous voulez des exemples dessus, vous pouvez consulter cette excellent article : http://datumedge.blogspot.fr/2012/06/java-8-lambdas.html
Cet article a été l'occasion de découvrir une petite partie de JAVA 8.Si vous voyez des erreurs ou si vous avez des commentaires, n'hésitez pas ! Dans un prochain article, on étudiera les lambdas ...