Heureusement, il est possible très facilement de forcer la version – pour cela il suffit d’une part de rajouter un « buildpack » dans les variables d’environnement de votre application:

heroku config:add BUILDPACK_URL=https://github.com/heroku/heroku-buildpack-nodejs.git#versions

puis de modifier le fichier packages.json pour rajouter une entrée « engines »:

{
    "name": "monAppli"
  , "version": "0.1.0"
  , "private": true
  , "dependencies": {
      "express": "2.5.6"
    , "jade": "0.20.0"
  },
  "engines": {
    "node": "0.6.x",
    "npm": "1.0.x"
  }
}

Puis les classiques

git add .
git commit -m "passage en en 0.6"
git push heroku master

Normalement vous devriez voir les lignes:

-----> Heroku receiving push
-----> Fetching custom buildpack... done
-----> Node.js app detected
-----> Resolving engine versions
       Using Node.js version: 0.6.8
       Using npm version: 1.0.106
-----> Fetching Node.js binaries

Et voilà, votre application tourne en 0.6.

Cela donne l’application web mon.instant-de-bonheur.fr qui permet de partager les petits (et grands!) moments de bonheur (sans aucun lien avec l’émission de France2, quoique…) et qui a été mise en ligne depuis quelques jours.

Pour les geeks, j’ai pris soin (ou du moins essayé) de documenter mon code, évidemment publié en opensource (license Apache 2.0) afin que d’autres puissent peut-être en profiter pour monter en compétence sur les technologies javascript (node.js, jade, expressjs) et noSQL (à travers mongodb).

Le code complet est disponible sur github via github.com/jraigneau/instant, et la version commentée et mise en forme peut-être revue sur le site même de l’application via mon.instant-de-bonheur.fr/about. Le code est améliorable, modifiable et ne respecte probablement pas les standards mais « It works ! » –  au passage je suis convaincu par l’utilisation de node.js: rapide, fiable et surtout très facile à utiliser pour un développeur même moyen.

1. Suivant votre système, installez Play! via le zip ou via brew:

brew install play

2. Installez le support java pour Play!

play install scala

3. Créez l’application avec le support java:

play new maSuperDemo --with scala

4. Testez que tout s’est bien passé:

play run

puis ouvrez votre navigateur sut http//localhost:9000. Normalement vous devez avoir une belle fenêtre résumant le fonctionnement de Play!. Passons maintenant au choses sérieuses.

5. Modifiez les dépendances du projet pour ajouter Casbah, la librairie Scala permettant de manipuler MongoDB.

# Application dependencies
require:
    - play
    - play -> scala 0.9.1
    - com.mongodb.casbah -> casbah_2.8.1 2.1.5-1

repositories:
  - scalatools:
     type: iBiblio
     root: http://scala-tools.org/repo-releases/
     contains:
       - com.mongodb.casbah -> *
       - org.scalaj -> *

Attention de bien utiliser la version 2.8.1 qui est la seule compatible avec Play! 1.2.3 à l’heure actuelle.

6. Forcez Play! à charger toutes les dépendances (qui seront stockées dans le répertoire /lib):

play dependencies

7. Préparez l’application pour le déploiement sur heroku: pour des raisons de simplicité nous allons utiliser la base MongoDB de heroku directement (pas de base de développement…c’est mal mais c’est une démo !).
Avant toute chose, créez un fichier .gitignore contenant:

/modules
/tmp
/lib

Puis la magie git habituelle

git init
git add .

et enfin la déclaration sous heroku (je ne donne pas de nom à l’application, Heroku m’en choisira un tout seul) et l’installation de l’addon mongodb (ici via mongolab mais mongoHQ ferait aussi l’affaire)

heroku create --stack cedar
heroku addons:add mongolab:starter

Point important: la commande heroku config vous permettra de récupérer l’url et le port de la base mongoDB automatiquement créée. Exemple:

MONGOLAB_URI => mongodb://nombase:motdepasse@urlmongolab:portmongolab/nombase

Ces données sont à intégrer dans la prochaine étape.

8. Créez un nouveau controleur dans /app/controllers/Messages.scala avec le code suivant:

package controllers;

import play.mvc._;
import com.mongodb.casbah.Imports._
import scala.collection.JavaConverters._

object Messages extends Controller {

//Création de la connexion et authentification
  val _mongoConn = MongoConnection("urlmongolab", portmongolab)
  _mongoConn("nombase").authenticate("nombase","motdepasse")

  def index = {
    val msgs = _mongoConn("nombase")("test_data").find( "msg" $exists true $ne "" )
    val msgStrings = msgs.map( (obj: DBObject) => obj.getOrElse("msg","") )
    Template( 'msgStrings -> msgStrings.asJava )
  }

  def save(msg:String) = {
    val doc = MongoDBObject("msg" -> msg)
    _mongoConn("nombase")("test_data").save( doc )
    Redirect("/")
  }
}

Vous noterez les transformations des méthodes « .asJava » qui permettent à Groovy (le langage de scripting intégré dans Play) de gérer les listes typique de Scala.

9. Ajoutez une vue pour gérer le controleur avec un fichier dans /app/views/Messages/index.html

<form action="@{Messages.save()}" method="POST"/>
  <input type="text" name="msg"/>
  <input type="submit" value="Add message" />
</form>

<ul>
  #{list items:msgStrings, as:'mess' }
  <li>${ mess }</li>
  #{/list}
</ul>

10. Modifiez les routes dans /config/routes

# Routes
# This file defines all application routes (Higher priority routes first)
# ~~~~

# Home page
GET     /                                       Messages.index
POST    /                                       Messages.save

# Ignore favicon requests
GET     /favicon.ico                            404

# Map static resources from the /app/public folder to the /public path
GET     /public/                                staticDir:public

# Catch all
*       /{controller}/{action}                  {controller}.{action}

11. Testez votre application en lançant la commande play run – normalement vous devriez être capable d’enregistrer des petites messages et de les voir apparaître à l’écran.

12. Déployez votre application sur heroku et admirez la !

git add .
git commit -m "Premier commit"
git push heroku master
heroku open

Ce petit tutoriel peut (doit) être complété avec le tutoriel officiel disponible sur le site de Play, en attendant vous pourrez jouer avec mon application sur http://glowing-fog-2793.herokuapp.com/.

Tutoriel basé en partie sur http://jaredrosoff.com/2011/05/getting-started-with-play-framework-scala-and-casbah/

Après quelques recherches sur internet, j’ai trouvé mon bonheur sur github ici et là. Pour gagner du temps dans mes futurs projets, j’ai alors transformé ces informations en un template giter8. Giter8 est un simple outil basé sur scala et SBT qui installe des templates stockés sur Github.

Une fois g8 et le gem heroku installés, mettre en ligne un projet scalatra devient alors très simple:

g8 jraigneau/scalatra-sbt-heroku.g8
cd monProjet
git init
git add . (conseil: pensez à mettre les répertoires de compilation (target) dans votre fichier .gitignore avant...)
git commit -m "Premier commit"
heroku create monProjet --stack cedar
git push heroku master
heroku open

Et voilà, votre navigateur s’ouvre sur la nouvelle application – la preuve en images:

Mon premier réflexe a été bien évidemment de m’assurer que macVim me permettrait de facilement commencer quelques développement en Scala. En cherchant rapidement sur le web, j’ai pu trouvé quelques astuces pour la coloration, la navigation à travers les méthodes…

En premier lieu, il faut installer le plugin Scala pour vim:

svn export --force http://lampsvn.epfl.ch/svn-repos/scala/scala-tool-support/trunk/src/vim

puis copier les fichiers obtenus dans votre répertoire .vim

Deuxième étape, l’installation du plugin Tagbar (téléchargement du fichier .vba puis méthode d’installation normale vim)

  vim tagbar.vba
    :so %
    :q

TagBar ne prenant pas en compte Scala, il faut légèrement modifier certains fichiers
Tout d’abord, création dans votre $HOME du fichier .ctags suivant

--langdef=Scala
--langmap=Scala:.scala
--regex-Scala=/^[ \t]*class[ \t]*([a-zA-Z0-9_]+)/\1/c,classes/
--regex-Scala=/^[ \t]*object[ \t]*([a-zA-Z0-9_]+)/\1/o,objects/
--regex-Scala=/^[ \t]*trait[ \t]*([a-zA-Z0-9_]+)/\1/t,traits/
--regex-Scala=/^[ \t]*case[ \t]*class[ \t]*([a-zA-Z0-9_]+)/\1/r,cclasses/
--regex-Scala=/^[ \t]*abstract[ \t]*class[ \t]*([a-zA-Z0-9_]+)/\1/a,aclasses/
--regex-Scala=/^[ \t]*def[ \t]*([a-zA-Z0-9_=]+)[ \t]*.*[:=]/\1/m,methods/
--regex-Scala=/[ \t]*val[ \t]*([a-zA-Z0-9_]+)[ \t]*[:=]/\1/V,values/
--regex-Scala=/[ \t]*var[ \t]*([a-zA-Z0-9_]+)[ \t]*[:=]/\1/v,variables/
--regex-Scala=/^[ \t]*type[ \t]*([a-zA-Z0-9_]+)[ \t]*[\[<>=]/\1/T,types/
--regex-Scala=/^[ \t]*import[ \t]*([a-zA-Z0-9_{}., \t=>]+$)/\1/i,includes/
--regex-Scala=/^[ \t]*package[ \t]*([a-zA-Z0-9_.]+$)/\1/p,packages/

Puis on va modifier le code du plugin TagBar (à priori dans ~/.vim/plugin/tagbar.vim), en rajoutant les lignes suivantes

" Scala {{{3
let type_scala = {}
let type_scala.ctagstype = 'Scala'
let type_scala.kinds     = [
  \ {'short' : 'p', 'long' : 'packages',  'fold' : 1 },
  \ {'short' : 'V', 'long' : 'values',    'fold' : 0 },
  \ {'short' : 'v', 'long' : 'variables', 'fold' : 0 },
  \ {'short' : 'T', 'long' : 'types',     'fold' : 0 },
  \ {'short' : 't', 'long' : 'traits',    'fold' : 0 },
  \ {'short' : 'o', 'long' : 'objects',   'fold' : 0 },
  \ {'short' : 'a', 'long' : 'aclasses',  'fold' : 0 },
  \ {'short' : 'c', 'long' : 'classes',   'fold' : 0 },
  \ {'short' : 'r', 'long' : 'cclasses',  'fold' : 0 },
  \ {'short' : 'm', 'long' : 'methods',   'fold' : 0 }
\ ]
let type_scala.sro        = '.'
let type_scala.kind2scope = {
  \ 'T' : 'type',
  \ 't' : 'trait',
  \ 'o' : 'object',
  \ 'a' : 'abstract class',
  \ 'c' : 'class',
  \ 'r' : 'case class'
\ }
let type_scala.scope2kind = {
  \ 'type'           : 'T',
  \ 'trait'          : 't',
  \ 'object'         : 'o',
  \ 'abstract class' : 'a',
  \ 'class'          : 'c',
  \ 'case class'     : 'r'
\ }
let s:known_types.scala = type_scala

Attention, ces lignes doivent être rajoutées dans la fonction function! s:InitTypes()

Et voilà – Vim est prêt pour Scala !

Tiré/traduit de latestbuild.net/scala-ctags-and-vim-tagbar

Il faut d’abord installer le module soit via l’IHM web , soit via la commande ((dans le répertoire de l’application)

heroku addons:add pgbackups

Puis simplement lancer une sauvegarde

heroku pgbackups:capture

Une petite vérification s’impose:

heroku pgbackups

qui renvoie normalement

D   | Backup Time         | Size   | Database
-----+---------------------+--------+----------------
b001 | 2011/08/18 11:08.22 | 39.2KB | SHARED_DATABASE
b002 | 2011/09/19 10:24.04 | 40.2KB | SHARED_DATABASE

Et finalement pour restaurer (avec b001 la base)

heroku pgbackups:restore DATABASE b001

Rappelez vous que la sauvegarde reste l’un des meilleurs moyens de sécuriser vos données… ]]> http://blog.zeneffy.fr/2011/09/19/sauvegarder-une-base-de-donnee-postgresql-chez-heroku/feed/ 0 http://blog.zeneffy.fr/2011/09/04/macvim-command-t-et-rvm/ http://blog.zeneffy.fr/2011/09/04/macvim-command-t-et-rvm/#comments Sun, 04 Sep 2011 18:55:28 +0000 Julien http://blog.zeneffy.fr/?p=436 MacVim (une forme de l’éditeur VIM adaptée à MacOS) est mon éditeur de prédilection actuellement malgré de nombreux autres essais (entre autres: Textmate, Kod, Sublime Text).

Il est très configurable et permet de rajouter de nombreuses fonctionnalités utiles: ici je vous parlerai du module Command-T qui permet de faire des recherches très fines et surtout pertinentes à travers les répertoires et fichiers d’un projet – un screencast est disponible sur le site de l’auteur.

Pour l’installer sur un mac avec RVM, il faut être vigilant sur la version de Ruby employée car MacVim ne compilant pas avec ruby 1.9.

Installation de MacVim via homebrew avec ruby 1.8.7:

rvm use system
/usr/bin/ruby -e "$(curl -fsSL https://raw.github.com/gist/323731)"
brew install wget macvim

Installation de CommandT à partir de vim.org:

wget http://www.vim.org/scripts/download_script.php?src_id=15560
mvim command-t-1.2.1.vba

Puis une fois MacVim ouvert:

:so %

En sortant de MacVim:

cd /$HOME/.vim/ruby/command-t
ruby extconf.rb
make

Et voilà normalement tout fonctionne, vous pouvez utiliser la version de ruby que vous souhaitez sans problème.

gem 'haml-rails'

puis lancer la commande bundle install

et finalement ajouter

config.generators do |g|
  g.template_engine :haml
end

dans le fichier config/application.rb (dans la classe « Application < Rails::Application ») – chaque scaffold sera automatiquement en Haml

En effet, pour créer mon squelette d’application « zen-hw », j’ai utilisé la commande

[julien.newton: zen-hw]$ express

qui crée par défaut une arborescence d’application Express – or par défaut le fichier app.js lancera la webapp via la commande

app.listen(3000);

qui fonctionne parfaitement en local (sauf si pow est installé, mais c’est une autre histoire) mais pas sur heroku, avec un beau crash de l’application visible via:

[julien.newton: zen-hw]$ heroku ps
Process       State               Command
------------  ------------------  ------------------------------
web.1         crashed for 8s      node app.js

Pour éviter ce point, il suffit de modifier app.js pour chaque application Express créée via la commande express pour utiliser process.env.PORT, ce qui donne à la fin du fichier:

var port = process.env.PORT || 3210;
app.listen(port, function(){
  console.log("Listening on " + port);
});

et voilà l’application fonctionne sous heroku !