Play Framework + Eclipse + Postgresql + Mercurial


English Version

play preparado alawelinux

Hans Poo, hans@welinux.cl, Santiago de Chile, Septiembre de 2012

El dicho “hay muchas formas de pelar un gato” nos ha motivado a mostrar como pelamos el gato del desarrollo web con Play.

Llevamos un año desarrollando con play usando un conjunto específico de herramientas de Software Libre. En este tutorial aprenderas a instalar y utilizar este entorno de desarrollo:

Lenguaje de programación Java, framework de desarrollo web Play, entorno de desarrollo integrado: Eclipse, base de datos PostgreSQL, control de versiones con Mercurial, gestión de incidencias con Redmine, y sistema operativo Linux distribución Ubuntu, la última edición hasta este momento 12.04 LTS.

Copiar trozos de código: Para copiar los trozos de código, haz doble click en ellos, presiona el botón derecho del mouse y selecciona Copiar. El shortcut/atajo de teclado para pegar luego en el terminal es Shift + Control + V.

Java 7

Abrimos un terminal e instalamos el openjdk de java con:

sudo apt-get install openjdk-7-jdk

Play 1.2.5.3

Podemos instalar en nuestra carpeta $HOME, o para todo el sistema, haremos lo segundo. En general los comandos de play los ejecutaremos en un terminal. Trabajaramos en la carpeta Descargas, abrir un terminal y ejecutar:

cd ~/Descargas

La colita de chancho: “~”, se reemplaza por tu carpeta home, de este modo el código que estamos mostrando queda más genérico, este símbolo normalmente sale con Alt + 4 en los teclados españoles, tu carpeta home también está disponible en la variable de entorno $HOME.

Descargamos el framework, podemos descargarlo con firefox o ejecutar lo siguiente desde la línea de comandos:

wget http://downloads.typesafe.com/play/1.2.5.3/play-1.2.5.3.zip

Descomprimimos y movemos al lugar por defecto para los programas agregados manualmente al sistema: /usr/local en nuestro computador:

unzip play-1.2.5.3.zip
sudo mv play-1.2.5.3 /usr/local/

Configuramos el acceso al framework través de un enlace simbólico para manejar de manera más comoda sus actualizaciones:

sudo ln -s /usr/local/play-1.2.5.3/ /usr/local/play

Creamos un enlace al ejecutable “play” que dejamos en /usr/local/bin, de este modo el comando play quedará disponible inmediatamente desde el terminal:

sudo ln -s /usr/local/play/play /usr/local/bin/play

Resumen de comandos ejecutados:

cd ~/Descargas
wget http://downloads.typesafe.com/play/1.2.5.3/play-1.2.5.3.zip
unzip play-1.2.5.3.zip
sudo mv play-1.2.5.3 /usr/local/
sudo ln -s /usr/local/play-1.2.5.3/ /usr/local/play
sudo ln -s /usr/local/play/play /usr/local/bin/play

Eclipse Indigo

Ir al enlace de descarga de eclise indigo http://www.eclipse.org/downloads/packages/eclipse-ide-java-ee-developers/indigosr2, en la barra de la derecha titulada Download Links y descargar la versión que corresponda de 32 o 64 bits Linux. Si no ha quedado en la carpeta $HOME/Descargas, muévelo ahí, luego lo descomprimimos desde la linea de comandos:

cd ~/Descargas
tar xzvf eclipse-jee-indigo-SR2-linux-gtk-x86_64.tar.gz

Creamos un archivo para que podamos ejecutar eclipse desde el lanzador de Unity.

mkdir -p ~/.local/share/applications

cat<<EOF>~/.local/share/applications/eclipse.desktop
[Desktop Entry]
Type=Application
Name=Eclipse
Comment=Eclipse Integrated Development Environment
Icon=$HOME/Descargas/eclipse/icon.xpm
Exec=$HOME/Descargas/eclipse/eclipse
Terminal=false
Categories=Development;IDE;Java
EOF

En el caso de Ubuntu 16.04, hay que dar permisos de ejecución a este archivo:

chmod 755 ~/.local/share/applications/eclipse.desktop

Copiar el lanzador recién creado a la barra de unity: Abre la carpeta donde ha quedado el lanzador con el siguiente comando:

nautilus ~/.local/share/applications/

Arrastra y suelta el archivo eclipse.desktop sobre la barra de Unity a la izquierda.

En Ubuntu 16.04 con Eclipse Mars, hay problemas con las librerías GTK, por lo tanto es necesario agregar la siguiente línea a eclipse.ini:

--launcher.GTK_version
2

Iniciar eclipse: Haz click en el ícono que ha quedado en el lanzador, en la caja de dialogo deja el campo Workspace como viene, enciende la casilla que dice “use this as the default …”, y luego presiona OK. Al iniciar la primera vez, eclipse creará la carpeta $HOME/workspace indicada, que es donde crearemos nuestros proyectos play.

Para los nuevos en eclipse les comentamos que lo que se presenta como escritorio de trabajo en Eclipse es un conjunto de Vistas agrupadas en una Perspectiva.

Asistentes de play para eclipse playclipse

Play dispone de algunas ayudas para trabajar en eclipse, colocará cuatro botones de acceso rápido en la barra de herramientas superior del eclipse:

  • New Controller
  • New View
  • New Model
  • Go to Route

Para ello tenemos que copiar un jar desde la distribución de play a la carpeta dropins de eclipse, ejecuta lo siguiente desde el terminal:

cp /usr/local/play/support/eclipse/org.playframework.playclipse_0.7.0.jar ~/Descargas/eclipse/dropins/

Luego reiniciar eclipse con File > Restart y ya tendremos los botones mencionados.

La primera aplicación play

No es nuestra intención repetir el excelente tutorial oficial de play en español, es un paso necesario para aprender play. En este caso es más la plataforma completa la que queremos mostrar, por tanto haremos una aplicación sencilla, una agenda de Amigos, que entre sus elementos contenga una galería de fotos, esto es para mostrar paquetes y esquemas.

Nos cambiamos a la carpeta $HOME/workspace recién creada por eclipse. De aquí en adelante usaremos el terminal y el eclipse al mismo tiempo:

cd $HOME/workspace

Creamos el proyecto play, copia y pega el siguiente comando en el terminal y presiona Enter cuando te pida confirmar el nombre del proyecto:

play new agenda

Probemos rápidamente el proyecto, ejecutémoslo.

play run agenda

Anda a firefox e ingresa a http://localhost:9000, luego ve al terminal presiona Control + C para finalizar la aplicación.

El comando “play run” levanta el play y ejecuta tu proyecto desde el terminal, por eso lo pudimos terminar con Control + C, si usas “play start” en vez de “play run”, el programa quedará ejecutando en el background como servicio y lo puedes monitorear mirando el archivo logs/system.out, en este caso para finalizarlo debes usar “play stop” desde la carpeta del proyecto. Esta última es la forma más común de ejecutarlo en producción.

Seguimos, nos cambiamos a la carpeta del proyecto recién creada:

cd agenda

La codificación de caracteres de las respuestas es dinámica en play y en las plantillas html, donde debe ir el encoding play ha dejado una variable, el problema es que los editores HTML de eclipse tienen problemas cuando ven este valor, por tanto la dejamos fija en UTF-8:

find . -name \*.html -exec sed -i 's/${_response_encoding}/UTF-8/' "{}" \;

Instalamos el sistema de control de versiones mercurial:

sudo apt-get install mercurial

Creamos el archivo de “cosas que no versionar” .hgignore apropiado para proyectos play, aquí usando here documents, pero también lo pueden hacer con cualquier editor:

cat<<EOF>.hgignore
^modules
^tmp
^precompiled
^test-result
^logs
^eclipse
^data
.*\.log$
\.classpath$
\.project$
.*\.pyc$
.*\.orig$
.*\.swp$
EOF

Archivo de configuración de tu cuenta de mercurial .hgrc, copia y pega el siguiente código en el terminal.

cat<<EOF>~/.hgrc
[ui]
username = Juan Perez
EOF

Las instrucciones anteriores han creado el archivo .hgrc en tu home, lo vamos a editar con gedit:

gedit ~/.hgrc

Donde dice Juan Perez, coloca tu nombre, y luego lo salvas con Ctrl + S. Recomendamos agregar gedit a tu barra de Unity.

Colocamos el proyecto bajo control de versiones

hg init
hg add .
hg commit -m'Inicialización del repo'

Mercurial al ser un DVCS (Sistema de control de versiones distribuido) tiene la Copia de Trabajo y el Repositorio siempre juntos, a diferencia de subversion (centralizado) donde siempre había un sólo repositorio y muchas copias de trabajo. El comando init convierte la carpeta actual en un repositorio mercurial vacio, a nivel de sistema de archivos, crea la carpeta .hg que representa el Repositorio Mercurial.

Con el comando add colocamos toda el contenido de la carpeta actual y sus hijos en control de versiones.

Puedes visualizar siempre el estado de la copia de trabajo actual con hg status. Puedes revisar el log de todas las revisiones con hg log.

No se crea una nueva revisión hasta que no haces un commit, que representa la unidad de modificación de datos, de gestión.

Eclipsificar

Eclipsificamos el proyecto play, esto hace que eclipse pueda importar y trabajar en forma nativa con nuestro proyecto play. En términos concretos crea una carpeta llamada eclipse y coloca entro otros archivos el .project y .settings de eclipse. Luego veremos que la carpeta .eclipse debe dejarse fuera de control de versiones por contener rutas absolutas de nuestro computador.

Si usas java 7 es necesario hacer el siguiente ajuste una (sólo una vez por computador) para agregar un parámetro a los archivos que genera play.

sed -i "s/%VM_ARGUMENTS%/-XX:-UseSplitVerifier/" /usr/local/play/resources/eclipse/debug.launch

El comando que eclipsifica el proyecto es el siguiente, recuerda repetirlo cada vez que modifiquemos las dependencias del proyecto.

play ec

Importar el proyecto desde Eclipse

Nos cambiamos a eclipse, selecciona el Menu File > Import > General > Existing projects into workspace y luego click en Next, presiona el botón Browse, selecciona el proyecto agenda desde la carpeta workspace, luego presiona Finish, el proyecto esta ahora importado en eclipse.

Para trabajar en proyectos play recomendamos la perspectiva Java EE, a esta conviene agregarle la vista Navigator: menu Window > Show View > Navigator, esta vista es un explorador de archivos genérico y nos va a servir para acceder rápidamente a la carpeta eclipse del proyecto, donde esta el lanzador de la aplicación agenda.launch.

El problema con la vista Project Explorer es que en la forma en que play coloca las librerías, estas ocupan un espacio vertical muy largo y dificultan acceder rápidamente al lanzador de la aplicación. En todo caso más tarde eclipse colocará un acceso directo al lanzador de la aplicación (botón de play verde) como del debugger (botón con el bichito) en la barra de botones superior.

Ejecutar el proyecto

Activa la vista Navigator con un click. Dentro del proyecto, la cuarta carpeta se llama eclipse, en ella estan los archivos de comandos para ejecutar y depurar nuestra aplicación sin salir del eclipse, por el momento nos interesan dos archivos uno para ejecutar el proyecto desde dentro de eclipse llamado: agenda.launch y otro para conectarle el debugger: Connect JPDA to agenda.launch, ojo que el debugger no levanta el proyecto, si el proyecto no está en ejecución y deseas debugear, debes levantarlo primero.

Haz click con el botón derecho del mouse en el archivo agenda.launch y elige la opción Run As > agenda con esto el proyecto comenzará su ejecución. Para debugear debes hacer click con el botón derecho en Connect JPDA to agenda.launch y seleccionar Debug as > Connect JPDA to agenda.

Test desde firefox

Conéctate a tu proyecto funcionando desde firefox accediendo a la dirección http://localhost:9000.

Eclipse muestra las salidas estándar y de errores de los proyectos en la vista Console que está abajo a la derecha, en ella hay un botón rojo cuadrado para detener el proyecto.

Configurar PostgreSQL

Para ser ordenado hay que crear para cada proyecto un usuario en el sistema operativo y en la base de datos; para postgreSQL, recomendamos dejar el usuario postgres sólo para administrar el cluster.

Crear usuario en el sistema operativo para el proyecto. Ejecuta el siguiente comando, y en las preguntas “Introduzca la nueva contraseña de UNIX:” y “Vuelva a escribir la nueva contraseña de UNIX:” coloca 123456, en “Nombre completo” ingresa “Sistema Agenda”, el resto lo dejas vacio y finalmente le dices que Si aceptas.

sudo adduser agenda

Instalar postgresql.

sudo apt-get install postgresql

Crear usuario agenda que será el dueño de la base de datos, cuando pida la password para efectos de pruebas colocar 123.

sudo su - postgres -c "createuser --no-superuser --no-createrole --createdb --pwprompt agenda"

Crear la base de datos con el usuario agenda:

sudo su - agenda -c "createdb agenda"

La idea es que todo el trabajo que deban hacer con la base de datos lo realizan conectandose en el terminal con esa cuenta haciendo sudo su – agenda.

Modificar application.conf para que play use la base de datos que acabamos de crear.

cd $HOME/workspace/agenda
echo "db=postgres://agenda:123@localhost/agenda" >> conf/application.conf

Secuencia por cada tabla (avanzado, opcional)

Como corresponde en la actualidad, play usa el estándar de persistencia de java JPA, los diseñadores de play han decidido utilizar Hibernate como proveedor de persistencia. Por defecto el adaptador de PostgreSQL de Hibernate creará una sóla secuencia para toda la base de datos, nos parece mejor tener una secuencia por cada tabla, por lo tanto estamos usando el siguiente adaptador de postgreSQL ligeramente modificado (creado por Burt).

En la vista Project Explorer (normalmente a la izquierda), hacer click con el botón derecho sobre app, luego seleccionar New > Package luego tipear utils como nombre del nuevo paquete y presionar Finish.

En el package utils recién creado haz click con el botón derecho del mouse, elige en el menu New > Class dale el nombre TableNameSequencePostgresDialect, y presiona Finish.

Haz doble click en el código siguiente, presiona el botón derecho del mouse y selecciona Copiar. Luego haz doble click en eclipse en la clase TableNameSequencePostgresDialect recién creada y presiona Control + A para seleccionar todo su contenido, y luego haz Control + V para reemplazar todo el código de la clase con lo que acabamos de copiar.


package utils;
import java.util.Properties;

import org.hibernate.dialect.Dialect;
import org.hibernate.dialect.PostgreSQLDialect;
import org.hibernate.id.PersistentIdentifierGenerator;
import org.hibernate.id.SequenceGenerator;
import org.hibernate.type.Type;

/**
 * Creates a sequence per table instead of the default behavior of one sequence.
 *
 * From <a href=
 * 'http://www.hibernate.org/296.html'>http://www.hibernate.org/296.html</a>
 *
 * @author Burt
 */
public class TableNameSequencePostgresDialect extends PostgreSQLDialect {

	/**
	 * Get the native identifier generator class.
	 *
	 * @return TableNameSequenceGenerator.
	 */
	@Override
	public Class<?> getNativeIdentifierGeneratorClass() {
		return TableNameSequenceGenerator.class;
	}

	/**
	 * Creates a sequence per table instead of the default behavior of one
	 * sequence.
	 */
	public static class TableNameSequenceGenerator extends SequenceGenerator {

		/**
		 * {@inheritDoc} If the parameters do not contain a
		 * {@link SequenceGenerator#SEQUENCE} name, we assign one based on the
		 * table name.
		 */
		@Override
		public void configure(final Type type, final Properties params,
				final Dialect dialect) {
			if (params.getProperty(SEQUENCE) == null
					|| params.getProperty(SEQUENCE).length() == 0) {
				String tableName = params
						.getProperty(PersistentIdentifierGenerator.TABLE);
				if (tableName != null) {
					params.setProperty(SEQUENCE, "seq_" + tableName);
				}
			}
			super.configure(type, params, dialect);
		}
	}
}

Desde el terminal ejecuta el siguiente comando (recuerda que estamos en $HOME/workspace/agenda), que modifica la configuración de play para que hibernate utilice el Adaptador que acabamos de crear:

echo "jpa.dialect=utils.TableNameSequencePostgresDialect" >> conf/application.conf

Controllers, Actions y views

Todo el html dinámico en play va en forma de templates o tags bajo la carpeta app/views. El punto de entrada a play esta manejado por las rutas, que finalmente te envían a un método estático (llamado Action) definido en un Controller. Al entrar al puerto 9000 estamos viendo la ejecución del action index en el controller Application, lo explicado anteriormente se ejemplifica observando el código del controller Application ubicado en app/controllers/Application.java que play ha creado:

package controllers;

import play.mvc.Controller;

public class Application extends Controller {

	public static void index() {
		render();
	}

}

El template que se renderea se puede pasar al método render, pero por defecto busca en la carpeta views/ControllerName en este caso views/Application el archivo llamado igual que el método, pero con extensión html, en este caso el metodo es index, por tanto el template a usar es index.html.

En eclipse hay dos shortcuts infaltables que levantan un live search de búsqueda, el Shift + Control +T para buscar Tipos y Clases Java, y Shift + Control + R para buscar cualquier recurso archivo html, javascript, etc.

Programa Hello world

Haz click en el botón derecho del mouse en el archivo app/views/Application/index.html, activa el menú Open With, veremos que eclipse nos ofrece varios editores para HTML, por defecto eclipse usa HTML Editor que es bastante bueno, recomendamos usar Web Page Editor, que tiene un buen trabajo WYSIWYG y también el editor que ha incorporado play: HTML (Play), que tiene algunas ayudas para viajar desde los templates a los controllers haciendo Control + Click sobre la llamada al Action, en este caso, cuando el Action que está en el template no existe, el editor ofrece crearlo en el Controller. Explora abriendo el archivo con ambos editores.

Con el restart de eclipse que hicimos, el servidor play se ha detenido, haz click nuevamente en agenda.launch y ejecutalo como ya indicamos anteriormente, como ya lo ejecutamos una vez podrías simplemente usar el shortcut Control + F11 o usar la botonera de eclipse como se ve en la siguiente imagen:

Botonera principal de eclipse

En el archivo index.html borra la llamada al tag welcome: #{welcome /} y en su lugar escribe:


Hello World

y presiona Control + S o haz click en el botón del diskette para salvar. Luego anda al navegador y recarga la página http://localhost:9000.

Captura de Parámetros

Como es clásico en el Hello World, el primer ajuste es para para que diga Hello Juan, Hello Pedro, etc; pasaremos un parámetro llamado nombre directamente en la URL, y veremos como capturarlo y mostrarlo en el template. Copia la siguiente dirección en tu navegador:

http://localhost:9000/application/index?nombre=Player.

La página sigue mostrando Hello World, claro, para capturar un parámetro lo debemos declarar como argumento del Action, Activa el Project Explorer y haz doble click en la clase app/controllers/Application.java, cambia la declaración del Action por la siguiente:

public static void index(String nombre) {

Luego para que el template lo reciba debemos pasarlo como argumento al método render:

render(nombre);

La clase Application queda de la siguiente manera, puedes copiar este codigo y reemplazar todo el código de Application.java.

package controllers;

import play.mvc.Controller;

public class Application extends Controller {

	public static void index(String nombre) {
		render(nombre);
	}

}

Modificamos el template app/views/Application/index.html para presentar el contenido de la variable nombre en vez de la palabra World, cambia Hello World por:

Hello ${nombre}

.. y recargamos la página http://localhost:9000/application/index?nombre=Player, para ver que ahora dice Hello Player.

Crear paquete Java y esquema en la base de datos

Para organizar un sistema que va a contener docenas de clases, es recomendable ser ordenado desde el principio: las tablas de la base de datos agrupadas en esquemas, y las clases Java en paquetes. En la vista Project Explorer activa el package app/models y presiona el botón derecho del mouse, New > Package, en el nombre escribe models.fotos y presiona Finish. Para crear el esquema equivalente en la base de datos haz lo siguiente desde el terminal:

sudo su - agenda -c "psql -c 'create schema fotos;'"

Si mantienen una sesión de terminal como usuario agenda basta que ejecuten psql -c ‘create schema agenda;’. Si estas dentro del interprete de comandos de postgres psql, bastaría con ejecutar create schema agenda;.

JPA/Hibernate no crea automáticamente los esquemas en la base de datos, hay que hacerlo manualmente como acabamos de ver con la instrucción create schema.

Crear la clase Foto

Diagrama de clases de la galería de fotos, generado con Bouml 4.21:

En la vista Project Explorer activa el package models.fotos y presiona el boton New Model, dale el nombre Galeria y presiona Finish, repite la operación New Model, esta vez crear la clase Foto.

Copia y pega lo siguiente en la clase Galeria, recuerda antes de pegar seleccionar todo el código con Shift + Control + A:


package models.fotos;

import java.util.List;

import javax.persistence.*;
import play.db.jpa.*;

@Entity
@Table(schema = "fotos")
public class Galeria extends Model {

@OneToMany(cascade = CascadeType.ALL, mappedBy = "galeria")
public List<Foto> fotos;

}

Con el editor de la clase Galeria aún activo aprovechamos de introducir dos shortcuts fundamentales. Ejecuta Shift + Control + F para formatear el código, y Shift + Control + O para organizar los imports. Luego copia y pega lo siguiente en la clase Foto:

package models.fotos;

import javax.persistence.Entity;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

import play.db.jpa.Blob;
import play.db.jpa.Model;

@Entity
@Table(schema = "fotos")
public class Foto extends Model {

	public String descripcion;
	public Blob image;

	@ManyToOne
	public Galeria galeria;

}

No vamos a hacer un tutorial del API de persistencia de Java JPA, que deberán estudiar por separado, pero destaquemos la anotación:

@Table(schema = "fotos")

Que permite indicar en que esquema de la base de datos se creará la tabla asociada a esta clase.

En este caso estamos viendo una composición, Foto está amarrada a Galería, la expresión de esto es el atributo mappedBy del @OneToMany de galería y la existencia del @ManyToOne en Foto, hay sólo dos tablas en la base de datos, no se ha creado una tabla para la asociación.

Ubicación de la tabla de la asociación

Si queremos que la clase Foto se use en otros contextos, y no solamente asociada a una Galeria, no usamos mappedBy y el proveedor de persistencia de JPA, en este caso Hibernate, creará una tabla asociación (y foto ya no tendrá la llave foranea de galería). Para indicar el esquema en que debe quedar la tabla asociación usamos la anotación @JoinTable junto al @OneToMany, todo queda de la siguiente forma:

Galeria

package models.fotos;

import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.OneToMany;
import javax.persistence.Table;

import play.db.jpa.Model;

@Entity
@Table(schema = "fotos")
public class Galeria extends Model {

	@OneToMany
	@JoinTable(schema = "fotos")
	public List<Foto> fotos;

}

Foto


package models.fotos;

import javax.persistence.Entity;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

import play.db.jpa.Blob;
import play.db.jpa.Model;

@Entity
@Table(schema = "fotos")
public class Foto extends Model {

	public String descripcion;
	public Blob image;

}

Recomendamos experimentar dropeando y creando el esquema de la base de datos, y ejecutando nuevamente el servidor play, para luego explorar con alguna herramienta como SQLPower o SQLEonardo, las distintas formas en que las antotaciones de JPA impactan en la creación de las tablas.

Comitear nuestro trabajo

Veamos el estado del proyecto con Mercurial.

hg status

Los archivos que salen con ? al principio es porque no estaban versionados, mercurial maneja las modificaciones en forma automática pero los nuevos archivos hay que agregarlos con add y luego comitear todo.

hg add *
hg commit -m"Primeros cambios"

Felicitaciones,

Haz completado el tutorial, te invitamos a realizar el tutorial oficial de play en http://playdoces.appspot.com/documentation/1.2.4/guide1. En Yabe, el tutorial que vas a realizar hay una Clase llamada User, User es una palabra reservada de postgreSQL y de otros motores de bases de datos, para que Hibernate cree correctamente la tabla debemos agregar una anotación @Table con comillas invertidas en el nombre a la declaración; debe quedar así:


@Entity
@Table(name = "`user`")
public class User extends Model {
....
}

Producción, proxear con servidor apache2 compartido (avanzado)

Crear un clon del proyecto para usarlo en producción, y ejecutarlo:

sudo mkdir /var/www/playapps/
cd /var/www/playapps/
sudo hg clone ~/workspace/agenda

Supongamos que estamos en el servidor de producción, ya le han colocado un id a la máquina de producción usando play id prod, y que han configurado los parámetros en conf/application.conf, prefijando con %prod. las variables que cambian en producción. Supongamos también que el puerto sigue siendo el 9000, y que el servidor apache es compartido por varios hosts virtuales y por tanto desean ejecutar bajo una subcarpeta de apache ej http://www.miservidor.com/agenda/. Entonces debemos agregar las siguientes claves en application.conf:

%prod.application.mode=prod
%prod.http.path=/agenda

Desde el terminal activar los módulos de proxy de apache con:

sudo a2enmod proxy
sudo a2enmod proxy_http

Modificar configuracíón de apache, dentro de la definición del host virtual por defecto de apache /etc/apache2/sites-enabled/000-default y antes de cerrar la etiqueta VirtualHost colocar.


ProxyPreserveHost On

<Location /agenda>
Allow from all
ProxyPass http://localhost:9000/agenda retry=0
ProxyPassReverse http://localhost:9000/agenda
</Location>

Luego de todo lo anterior reiniciamos apache y play.

cd /var/www/playapps/agenda
play stop; play start
sudo /etc/init.d/apache2 restart

Partida automática luego de un reboot

En construcción…

Nuestra empresa promociona el software libre, ofrecemos charlas y presentaciones gratuitas a las instituciones de educación, y cursos de capacitación y transferencia tecnológica a empresas.

Preparado por Hans Poo, hans@welinux.cl, Santiago de Chile, Septiembre de 2012.

3 thoughts on “Play Framework + Eclipse + Postgresql + Mercurial

Responder a Juan Almendras O. Cancelar respuesta

Tu dirección de correo electrónico no será publicada. Los campos necesarios están marcados *

Puedes usar las siguientes etiquetas y atributos HTML: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>