New Year’s resolutions

It’s just not a good start if I made my new year’s resolution on January 9th, but it’s better if I do this in January than in July, isn’t it? One of the recommendations I read more about how to achieve new year’s resolutions, is I should put my resolutions in writing and keep them visible. So,Where better than in the blog? Moreover I commit to keep them with my imaginary readers. Here we go!

  • Love me more. There are plenty of people willing to get my life complicated so I don’t need to help them.
  • To say what I think more often. Let’s face it, the 6000 7000 million people, I can’t like everyone so I’m not going to try it anymore.
  • Get my degree finally! Even if I should put fine arts in second place.
  • Take control over stress situations, and therefore …
  • Assume that sometimes I can not do everything.
  • Go much more often to the pool.
  • Sign up for yoga (and then go).
  • Cooking new recipes (and take them in tupperware).
  • Drink plenty of water.
  • Go to a forest aka be less urbanite.
  • Take a trip on horseback.
  • Learning to skate (!)
  • Make two craft projects per month (minimum), and one of them should be  taking a picture every hour as DaintySquid does.
  • Blogging, better and more often.
  • Do not judge books by their covers (or the people by what they read). Read the Lord of the Rings and GEB to compensate.
  • Be more sociable, online and in person.
  • Pamper my friends. Write them, spend more time with them, because let’s be honest they are awesome.
  • Wear lipstick more often.
  • Do not sleep with my makeup on.
  • Clean my brushes every Sunday.
  • Wear SPF every day.
  • Do not use toxic cosmetics  (there are so many!)
  • Find my signature parfum. (and my partner doesn’t think it is an old lady parfum <3)
  • Having a better posture and go to a physiotherapist when my back hurts. Not when it hurts a lot, even If the physio scold me.
  • Be awesome in emacs or vi. Editors holy war in the comments, please.
  • Learning a new programming language. In all likelihood Ruby will be the one.
  • Improve my python, java (android), Objective-C, Git … skills.
  • Write cool tutorials.
  • Use better programming practices (for real).
  • Develop a cool (pet) project
  • Collaborate with a open source project.

I don’t dare to count how many resolutions I wrote because there are a lot. ¿Too many? Maybe, We will see by the end of the year. Happy new year’s resolutions everyone.

Posted in Sin categoría | 3 Comments

Why should I develop native mobile application (sometimes)?

When we faced the question about if we should develop a web mobile application or a native mobile application, there is no universal answer (although sometimes, reading some articles, it seems there is one). When we begin a new development, first of all we must begin with a requirements analysis and functionalities that we are going to implement, and based on these we can make decisions. Just like when an architect designs a building, does not arise if there are good or bad materials or techniques, the architect just think if these materials or techniques are suitable for this particular work. We should think about every developmet independently and carry out a specific analysis for the application we will develop (otherwise the bogeyman will come and he will take away all our work, developers
who worked during the software crisis will tell us that this is true).

The purpose of this post is to analyze the case of developing a mobile application for Sakai OAE, of course, this is my analysis and I will be happy to rectify any mistake or any approach that can be wrong. Anyway, if you are interested in something more generic, google is our friend, simply search for “native apps vs web mobile” and you could spend all evening reading tons of articlees about this subject.

During this GSoC, two mobile applications are being developed for Sakai, and each one follows a different approach.  I sincerely believe that both decisions are correct. I’m sure that Kasun Lakpriya and Steve Swinsburg who are developing the web-based mobile application for  Sakai CLE, will give you plenty of good reasons why a web application makes sense to Sakai CLE. I’ll focus on Sakai OAE.

Sakai is a young web application OAE,  based on well-recognized standards, such as ajax or json, its design completely revitalizes the user experience by improving the workflow for both teachers and students. It is a highly scalable application that is developed following best practices …  It is definitely a really cool a web application. In fact, thanks to the hard work being done by the ux team, we can browse the web application using a mobile device and the application still will look really nice. So, in my point of view, since we have a good web application that with small changes may well be a mobile web application,  it makes more sense to try to take advantage of the possibilities that native applications will give us.
And what these possibilities are? Well these are some of them that we could use in Sakai OAE, but certainly these aren’t the only ones:

  • Connectivity (Off-line mode):  Although it’s becoming less common, not all places have a good Internet connection, in  Spain from where I write at least this is so. And web applications need, obviously,  Intenet connection to work (even though we can achive some things with html5 and Google Gears). So being able to have the application running all the time is an advantage, we won’t lose an alarm that warning us a deadline of a job, or stop reading some content because we don’t have an Internet connection.
  • Improve the user experience: Native applications, in general, improve the user experience, not only by the performance they can achive, but to use elements of the user interface of the device itself, although, of course this can also be emulated. It is also very interesting the possibility of having the application running in the background and receive certain notifications, as twitter apps do.
  • Device-based caching:Certain information could be store encrypted on the device itself, which is very useful for improving the user experience, not forcing him/her to introduce the same data each time.
  • Using the device features: This property  could seem a bit strange in case of an educational application, but if you think about  it  is not.  For example, when a teacher creates an activity, he/she could not only tag the date and time whe the activity will be done,  also it is possible to introduce aGPS address indicating the place where the activity is take place, which is really helpful if  we think about  field practices, especially large campus or for students with no spatial orientation (this is my case).  And surely we could imagine a lot of creative utilities using phone services such as the agenda or the camera. Why should we limit it?
  • Discoverability: It’s really easy to find an application in the market / app store.
  • Performance:  This is, in my opinion, the jewel in the crown of native applications. We can develop threads, use devices notifications, and make the application run in the background… And in the case of our application, where normally users turn on the app early in the morning when they arrive to university and they won’t turn off until they go home, this is a very interesting feature to exploit.

Although there are also mobile applications features negative, we can see the positive side of these (or at least,  do not consider them so negative)

  • Automatic Updates:  Web applications are updated automatically, while in the case of native applications we should upload them to market/app store and wait util the user updates them. This is initially a point for Web applications, but from my point of view, this is not so negative for Sakai OAE. The mobile application of a large university, must be stable and not constantly updated unless absolutely necessary (I’m thinking of a security bug), so we shouldn’t worry too much.
  • The censorship of the market/app store: I have write market/app store because I don’t want to not arouse suspicions, but really where the applications pass quality tests and can be rejected is at the appstore. Again, this seems quite negative, but an application is rejected by quality issues primarily (or duplicate a service of IOS, which is not the case), which obliges us to work hard on the quality of the application, and Apple is not particularly ambiguous on how we should develop applications. If we’ll see it  this way, I honestly do not think it’s an inconvenience at all.

And since not everything could be so beautiful, there are features that are inherently negative (if you can see a positive side please tell me!):

  • Reaching the audience: Although Android IOS and monopolize the market for mobile devices, these are not the only platforms, which makes our mobile applications fail to reach the audience. But as I mentioned in the introduction, Sakai OAE is a good web application that can be accessed from any mobile browser.
  • Maintenance: This really is a handicap. A native application implies that we must develop at least two projects for IOS and Android, and the rise of Windows Phone makes me think than maybe for this one too. This multiplies the cost of development and maintenance. I’m developing it for IOS and Android, and I suffer the problems of implementing functions in one platform that are completely different in the other, I can not deny this. Some months ago I was naive because I though that the development and maintenance costs would be lower since both apps are restful applications and the same web services are called. Anyway, Sakai community is big and great and I think the advantages outweigh the disadvantages.

I don’t mean that web applications can’t work as native applications. And every day we will find new frameworks to simply the work and get better performance.

To summarize, I don’t think there is no good or bad answer about what kind of app develop. This is my analysis, and of course there are many nuances to all the features I’ve listed, I won’t be surprise me if I’m completely wrong in more than one point, so I encourage you to leave me any comment with your thoughts and talk on here or IRC #sakai where you can find me as AdaHopper.

 

 

 

 

 

Posted in Sin categoría | 1 Comment

First month report in GSoC

Well, it’s been a full month (and a little more), since I started working on coolest grant I know: GSoC. So it’s time to make a properly report about project status, mainly to keep up to date with developments in the Sakai developer community.

I can only begin by thanking the work done by my mentor, Carl Hall, who patiently read my long post and still more patiently answer all my questions. Thanks Carl :)

I wish more things were finished at the end of this first month. But as recently I completed an important milestone, so I can be positive reviewing reached objectives  above remaining objectives. Moreover, it’s normal in the first stage takes a little bit longer development because I had to learn the technologies we work on the project (Objective-C, I’m looking at you, weirdo language), refresh the knowledge stored in layers of dust in my head (I’m sorry I left just Android), inquire about Sakai OAE (beautiful breath of fresh air I am sure will revitalize Sakai) and finish my exams (the GSoC starts early for European students).

But no excuses, let’s focus on the things that if I achieved which really matters.

Sakai OAE: thanks to jar file that Carl gives me, put into operation a local version of Sakai has been trivial. So I could concentrate on reading the documentation and play a lot with Sakai trying to understand the basic operation of the application. The existing documentation is not extensive, but is compensated by the high availability which the project developers have to answer questions. If you have any problems, I would recommend that you to pass through the irc channel  #sakai, there are always good people willing to help, or the mailing list sakai-dev,although the specificity for Sakai OAE is sakai -ui-dev. I have also found very useful documentation on quality tests because I have allowed to understand the user’s work flow in Sakai.

Mock up: in the presentation of the project  I’ve already showed some mock ups of the application and during this time we have been working, Kasun Kakpriya and I, trying our two mobile applications were most similar, so the user experience will be as similar as possible between the two mobile versions of Sakai CLE and Sakai OAE. We agreed in the work flow of the application, so that the two applications would have the same work flow and differ in some of the screens. This gives us flexibility to offer the best mobile version of each of the versions of Sakai and maintain the user experience.  Moreover, regarding the decision that what mock up I will implement , I am still awaiting a answer from the design team Sakai OAE, but I preferred to continue developing the inner part of the application and wait a little bit longer to UI team could answer me. So, if you are part of the design team, would be really nice to get some feedback (thanks!).

Skeleton application for Android : it is ready the skeleton of the Sakai application on Android. It is a tiny skeleton for now. It has basically the view with the log in and a second view where he arrived after identifying the user. Created packages are also organized by the java classes as well as the internationalization files.

Skeleton application for iOS: idem in IOS. Although , as I said in the introduction:  window management in IOS is very strange. Maybe it’s because I already have experience in Android and it takes me more work to switch, or because management is really weird (I’d bet on the latter ;) ).

Authenticate users in Android: this is the milestone I have achieved.  Users can now authenticate themselves sending its credentials. _Carl Hall and I,  studied the possibility to authenticate users using the OAuth protocol, even it is a standard that is spreading rapidly, the implementation of this protocol is beyond the aim of GSoC. Also Nakamura’s team is working on this. Nevertheless, the application is ready to change an authentication method for another one, so after the change will be not complicated.

I had this post ready for two weeks, so sorry for the delay. As you will understand the application development has advanced. If you will like to follow the development daily I will suggest to follow the repository: https://bitbucket.org/mrs.hopper/nellodeeoae

I hope you are interested about the project, I would like to hear some feedback. And if you have anything to ask or suggest me, plese do not hesitate.

Posted in Programación, Sakai OAE | Leave a comment

Android, primera cita

Si yo tuviera que ser de esas personas que pronostican el futuro de la tecnología seguro que dejaba frases para la historia. Por catastróficas. Y apesar de mi poquito tino, hay cosicas que en cuanto las ves sabes que van a zarandear el modo en el que nos acercamos a la tecnología, una de esas cosas es android.

¿Las claves del éxito?  Pues en primer lugar que existen muchos terminales que han decidido apostar por Android, esto es bueno para los usuarios que pueden acostumbrarse más o menos a una interfaz y para los desarrolladores es importantísimo un único programa puede ejecutarse en un montón de terminales sin tener que volvernos locos en los detalles de hardware. Otro buen motivo es que el framework es abierto,

Os cuento un poquito de historia, (muy breve). En 2005, Google compró una compañía llamada Android Inc., y los rumores se dispararon: ¡Google va a crear un google-phone! ¡Señora, esconda a sus niñas!. Bueno, en el 2007 se anuncia la Open Handset Alliance donde estan un montón de compañías importantes

1. Instalar JDK

En MacOS X, que es el sistema operativo para el que estoy preparando la primera cita, la JDK viene instalada por defecto, así que este paso directamente nos lo podemos saltar. (Gracias Steve :) )

2.Instalar Eclipse

El siguiente apartado os informo que no contendrá spoilers de la peli de vampiros descafeinados, podeís leer sin miedo (la que tiene miedo soy yo).

Vamos a la página de descargas de Eclipse y ahí escogemos Eclipse IDE for Java EE Developers (188 MB) si escogemos otro luego hay que instalar plugins adicionales y es un rollo. Cuando tengamos el archivo comprimido lo descomprimimos y dejamos la carpeta en Aplicaciones. Dentro de esta carpeta esta el ejecutable de eclipse.

3. Instalar la SKD de Android

La SDK de Android se distribuye a través de la página de Google: http://developer.android.com/,  pinchamos la pestañita de SDK y nos descargamos el paquete que corresponda a nuestra plataforma de trabajo. En mi caso android-sdk-mac_86 paquete. Lo descomprimimos donde queramos instalarlo.

Para no tener que poner la ruta en la terminal cada vez que queramos ejecutar alguna de las herramientas de android, vamos a colocar la ruta de donde hemos descompirimido la carpeta tools de la  sdk en el path. Es decir, mi carpeta tools de la sdk esta aquí:

~/android/android/android-sdk-mac_86/tool

Así que voy a abrir el fichero .bash_profile que esta en la raíz de mi usuario (en ~/.bash_profile) y añado la siguiente línea:

export PATH=${PATH}:~/android/android-sdk-mac_86/tools

Ahora ejecuto el programa android que esta dentro de la carpeta tools, como he añadido a la ruta simplemete tecleo:

android

Abrirá el SDK y AVD Manager, pinchamos en la pestañita  Available Packages y selecionamos lo paquetes que queramos instalar. Como yo soy muy avariciosa los cojo todos, y pinchamos en instalar todos, aceptamos la licencia y ya tenemos la sdk instalada.

4.Instalar el plugin de Android para Eclipse

Añadiremos el repositorio a Eclipse, para ello arrancamos eclipse (si no lo tenemos ya encendido) y desde el menú vamos a “Help->Install new software” y añadimos un nuevo sitio:

Name: Android plugin

Location: https://dl-ssl.google.com/android/eclipse

Seleccionamos el paquete de Developers Tools y lo instalamos aceptando la licencia. Sólo nos queda decirle donde esta la SDK . Vamos a “Eclipse->Preferencias” y pinchando en la pestaña de Android ponemos la ruta de donde hemos instalado la skd de Android, es decir: ~/android/android-sdk-mac_86. Cuando pulsemos “Apply” podremos ver todas las versiones de la SDK que tenemos disponibles. Y con esto y un bizcocho ya tenemos el entorno de desarrollo instalado.

5. Crear un emulador

Abrimos la SDK o dentro de eclipse podemos hacer clic en el botoncito de Android de la barra de herramientas y pinchamos en la pestañita “Virtual Devices”  y aquí a “New…”, rellenaremos las características que queremos que tenga nuestro emulador de android. Dejo una captura de pantalla con las que tiene uno de los que he configurado.

Creando un androide virtual

Creando un androide virtual

Terminamos haciendo clic en Create AVD, y… ¡Listo! Ya tenemos nuestro bonito entorno para empezar a trabajar con Android.
¡Que vaya bien la cita! :)

Posted in Programación | Tagged | Leave a comment

Poniendo guapo a Eclipse para trabajar con Sakai

A mi no me cae bien Eclipse y yo a él tampoco, eso es así. Le juré odio eterno mientras realizaba un proyecto de programación en la carrera (Pedro, amigo, que mal nos lo hizo pasar eh?), era extraño, lento y consumía más recursos que una alcaldesa corrupta en Vouitons. Sin embargo tras el congreso de Sakai, me di cuenta que si tanta gente lo utilizaba quizás yo estuviera equivocada.

Así que vamos a probar. Eclipse es un IDE  que cubre las necesidades perfiles de programadores muy distintos, así que es como una copa de helado con un montón de sabores, ¿apetecible? si, si tiene el sabor que nosotros queremos y no un montón que no nos gustan (o no nos apetecen) y nos tenemos que comer a la fuerza. En este tutorial vamos a hacer nuestro banana split particular para sakai.

1. Instalar Eclipse

Lo primero que tenemos que hacer es descargar Eclipse IDE para desarrolladores de Java EE.

Instalar eclipse es extremadamente simple, lo único que hay que hacer es descomprimirlo en Aplicaciones y ya esta. Vamos a ejercutarlo para comprobar que funciona ejecutando eclipse que esta destro de la carpeta de eclipse.

Ahora nos toca ponerle el sirope y es que la configuración por defecto de memoria se queda bastante corto para manejar todas las aplicaciones web de Sakai. Cerramos eclipse si lo tenemos corriendo, y con el botón secundario pinchamos en el ejecutable de eclipse para entrar en la carpeta Contents\MacOS, buscamos un fichero que se llama eclipse.ini, vamos a editar ahí las variables de configuración. En mi fichero esta esto:

–launcher.XXMaxPermSize
256m
-vmargs
-Dosgi.requiredJavaVersion=1.5
-XstartOnFirstThread
-Dorg.eclipse.swt.internal.carbon.smallFonts
-XX:MaxPermSize=256m
-Xms40m
-Xmx512m

y vamos a convertirlo en:

–launcher.XXMaxPermSize
256m
-vmargs
-Dosgi.requiredJavaVersion=1.5
-XstartOnFirstThread
-Dorg.eclipse.swt.internal.carbon.smallFonts
-XX:MaxPermSize=256m
-Xms128m
-Xmx1024m
-XX:+UseParallelGC

2. Añadir el plugin Web Tools Project (WTP) a eclipse

Este plugin hay que añadirlo en caso de que nos bajemos la versión Classic de eclipse, pero viene de serie con el IDE para desarrolladores de Java EE, así que un pasito que nos podemos saltar.

3. Añadir el plugin subclipse a eclipse

Tenemos que tener eclipse ejecutandose para poder instalar este plugin (como cualquier otro en realidad). Pinchamos en Help/Intall new software… (el caso es que me lo podía poner en castellano) y en “Avaible software sites”, esto nos mostrará una lista con los sitios disponibles desde donde podemos bajar plugins. En este repositorio vamos a añadir la dirección de Subclipse, simplemente pinchamos en el botón “Add..” y lo rellenamos como en la siguiente imágen:

Configuración del respositorio

La url, por si no se ve bien es:  http://subclipse.tigris.org/update_1.6.x

Le damos a Ok y ahora vamos a configurar la actualizazión. En Work site pondremos el repositorio que acabamos de añadir y pinchamos en el cuadro de selección de Subclipse (a continuación hay una captura de pantalla sobre como se hace). Pinchamos en Next y aceptamos los términos de uso del plugin, y así de sencillito tendremos el plugin instalado, solo nos queda reiniciar el IDE cuando nos lo pida.

Configuración de subclipse

El último paso en este apartado en la guía de Sakai es opcional, pero como somos programadores muy majos que no nos gusta nada ensuciar el código y subir al repositorio los directorios bin y target, pues vamos a hacerlo. (Vale, soy un poco radical, pero es por el bien comun :) )

Vamos a Eclipse->Preferencias y entramos en el menú Team->Ignored Resources. Y añadimos: “bin”, “target” y “m2-target”, aplicamos cambios y ya lo tenemos listo.

4. Añadir el plugin de maven a eclipse

Volvemos a ir a  Help/Intall new software… y añadimos el repositorio  pinchando el botón “Add..”  y rellenamos:

Name: Maven

Location:http://m2eclipse.sonatype.org/sites/m2e

Seleccionamos el plugin de Maven, teniendo este repositorio activo y lo instalamos aceptando la licencia y como antes pulsando Siguiente un par de veces.

5. Importar el código de sakai en Eclipse

Antes de importar el código, desde la terminal vamos a la ruta donde tenemos el código que queramos importar y tecleamos :

mvn eclipse:clean

mvn eclips:eclipse

Así crearemos los proyectos para que después eclipse pueda importarlos.

Arrancamos eclipse y vamos a cambiar a un espacio de trabajo para sakai, lo voy a llamar WS-Sakai (estoy original, Picasso tiembla), vamos a  File -> Switch Workspace y ponemos la ruta del espacio de trabajo, que al final es una carpeta que colocamos donde mejor nos venga.

Y ahora va lo divertido (o no), vamos a importar el código a sakai.

Vamos a Eclipse->import->Existing Projects into a workspace. Y en la raíz que nos pide del código ponemos la raiz de nuestro código de sakai. Pinchamos en finalizar y nos importará el código.

Aparecen errores en proyectos (algunos si tenemos suerte, un montón si no), esto es debido a que cuando le decimos a maven que cree los proyectos de eclipse hace algunos de más, así que tendremos que quitar el código que de error.

¡Y ya esta! ¡Ahora a trabajar! :)

Posted in Programación, Sakai | 1 Comment

(Español) Como tener dos (o los que quieras) fuentes de sakai instalados {instalando sakai 2.7.0}

Ahora que ya tenemos nuestro flamante código de sakai, queremos otro (una versión estable por ejemplo estaría bien). No es avaricia, os lo prometo, es necesidad.

En este post y en el siguiente veremos como instalar sakai 2.7.0  y sakai 3 y poder desplegar un código u otro en función de nuestras necesidades (veis como era necesidad). Vamos al lío.

1. Instalar y configurar tomcat

Necesitaremos un tomcat nuevo y limpito sobre el que despliegue el código de sakai que vamos a instalar. Al principio parece un jaleo tener varios tomcats pero es la solución más eficiente para no tener después quebraderos de cabeza con las dependencias. Como yo tengo guardado el paquete de tomcat simplemente lo descomprimo en una ruta adecuada. En mi  caso va a ser:

~\sakai\tomcat-2.7.0

(por razones obvias), así me acuerdo de que tomcat va con que código. El siguiente paso, es darle permisos de ejecución a los scripts:

sudo chmod ug+x *.sh

Añadimos el conector para mysql, lo tenemos en el tomcat anterior o lo podemos volver a bajar de aquí, en cualquier caso, lo colocaremos en $CATALINA_HOME/common/lib, de este modo tomcat lo encontrará (y no nos volverá locos.as con un mensaje de error gigantesco, justo como me ha pasado a mi).

A continuación modificamos el fichero server.xml (se encuentra en /tomcat/conf/server.xml) y en la configuración del puerto de conexión, vamos a añadirle la codificación para carácteres utf-8, al igual que hicimos cuando instalmos la primera vez.

Creamos la carpeta sakai detro de tomcat, y aquí pondremos copiar un fichero de properties limpio como el que tenemos en el código de sakai, dentro de /reference/docs/sakai.properties. Pero como yo quiero tener la misma configuración que en el código anterior pues voy a coger el properties que ya tengo configurado en el tomcat anterior. Elijamos el fichero que elijamos,  lo copiaremos a la carpeta sakai que acabamos de crear.

cp tomcat/sakai/sakai.properties tomcat-2.7.0/sakai/

Los amigos de Sakai, nos dicen que hace falta añadir unas opciones de java para que algunas herramientas jsf compilen correctamente con java 1.6. Como esta es la versión que tengo yo instalada voy a añadir las opciones al fichero de perfil.

open ~/.bash_profile
export JAVA_OPTS="-server -XX:+UseParallelGC -Xmx876m -XX:MaxPermSize=2160m -Djava.awt.headless=true -Dsun.lang.ClassLoader.allowArraySyntax=true -Dorg.apache.jasper.compiler.Parser.STRICT_QUOTE_ESCAPING=false -Dhttp.agent=Sakai"

Resulta que hay también unas opciones para localizar Sakai por defecto, esto es totalmente opcional, las opciones (valga la redundancia) que configuran esto son -Duser.language y -Duser.region, en mi caso españa (es):

export JAVA_OPTS="-server -XX:+UseParallelGC -Xmx876m -XX:MaxPermSize=2160m -Djava.awt.headless=true -Dsun.lang.ClassLoader.allowArraySyntax=true -Dorg.apache.jasper.compiler.Parser.STRICT_QUOTE_ESCAPING=false -Dhttp.agent=Sakai -Duser.language=es -Duser.region=ES"

2. Descargar y desplegar el código de sakai

Esto va mucho más rápido que la última vez. Ya vamos a descargarnos el código de sakai tecleando en el siguiente comando en la terminal:

svn co https://source.sakaiproject.org/svn/sakai/tags/sakai-2.7.0/ sakai-2.7.0

Antes de desplegar tenemos que decirle en que tomcat queremos hacerlo, así que tendremos que modificar la variable de entorno $CATALINA_HOME y nada más, porque como recordareís habíamos parametrizado la configuración de maven, así que con este simple cambio ya lo tenemos preparado para desplegar dónde toca.

export CATALINA_HOME=~/Trabajo/Sakai/tomcat-2.7.0/

Pues a desplegar!

cd sakai-2.7.0/master
mvn clean install
cd ..
mvn clean install sakai:deploy -Dmaven.test.skip=true

Y ya esta :) , ya tenemos nuestros dos códigos de sakai desplegados. Ahora segun arranquemos uno u otro tomcat tendremos la versión de sakai que queramos.

Posted in Programación, Sakai | Leave a comment

Instalar sakai trunk (desde las fuentes)

Estoy preparando a mi niño para el intenso verano que nos viene y es que estaré desarrollando un proyecto para el Gsoc (!). Y hay tanto (¡TANTO!) que hacer que la verdad es que estoy un poco aturdida, así que como antídoto voy a aplicar el mantra “Divide y vencerás” que tan buen resultado le da a todo el mundo. Y mi primera etapa va a consistir en crear un entorno de trabajo listo para la acción.

Mi mac, en adelante Noam, es un macbook de 13″, (es chiquitico, sí, pero ya vereís desde que sitios acabaré trabajando ya que voy siempre con él), corriendo mac os x 10.3.6. Así que este va a ser mi estación de trabajo y todas las cosicas que explique pues como es lógico “funcionaran” con estos requisitos técnicos.

Instalar Sakai es un infierno y eso es así, (espero que mi mentor no lea esto). Y por más veces que lo haga no es que mejore mucho el proceso, eso sí, cada vez soy más paciente y poquito a poquito los errores me van sonando, pero en definitiva algo va a fallar, no tengas miedo, al menos la comunidad es grande y ayuda a las pobre hormiguitas como yo.  Allá vamos pues…

1 .Verificar / Instalar Java 1.5

Pirmer paso de la guía y primer paso que me voy a saltar (luego me quejo de que no vayan las cosas). En mi sistema operativo java viene preinstalado por defecto. Simplemente lo comprobamos escribiendo en la terminal:

noam:~ ada$ java -version
java version "1.6.0_17"
Java(TM) SE Runtime Environment (build 1.6.0_17-b04-248-10M3025)
Java HotSpot(TM) 64-Bit Server VM (build 14.3-b01-101, mixed mode)

Y efectivamente ahí esta Java, pero es Java 6.0. con sus 64 bits más chulo que un ocho. Vale, como la experiencia es la madre de la ciencia, aunque la comunidad recomiende instalar Java 5.0. a mi esta versión no me da ningún problema, y Steve también dice que le funciona, así que al siguiente paso.

2. Instalar/Verificar mysql 4.1

Segun pone en la guía al parecer con mysql 5.0.x funciona también bien, y como soy una personita valiente he decidido bajarme la úlima versión que estaba en el respositorio: la versión 5.1.46. Me he bajado un fichero dmg desde la página oficial de mysql. Lo pero es que hay que pasar por el aburrido proceso de registrarnos.

Vale ya  tenemos el .dmg , lo montamos y e instalamos los dos paqueticos que tiene la imagen, como es un proceso de siguiente siguiente es fácil a más no poder. Y en un periquete tenemos mysql instalado. La ruta de acceso es /usr/local/mysql, pero como es un rollo acceder así vamos a ponerlo en el fichero .bash_profile añadiendo la siguiente línea:

export PATH=$PATH:/usr/local/mysql/bin

Vamos a poner la contraseña de root para poder empezar a jugar con nuestra base de datos. Para ello tecleamos:

$ ./bin/mysqladmin -u root password new_password

Claro que si lo haces sustituye new_password por tu nueva contraseña :)

Un alidado bueno bueno para trabajar después será el Sequel pro, un estupendo visor/editor para trabajar con nuestra base de datos en mac.

3. Crear la base de datos de Sakai y el usuario

O bien por la teminal o con el programita, accedemos a mysql con el usuario root y su contraseña. Como yo soy más de terminal pongo los comanditos aquí:

$ mysql -u root -p
mysql&gt; create database sakai default character set utf8;
mysql&gt; grant all privileges on sakai.* to 'sakai'@'localhost' identified by 'user';
mysql&gt; flush privileges
mysql&gt; quit

Y con esto ya tenemos nuesta base de datos lista para seguir instalando cositas.

4. Descargar y configurar Maven

Maven es una herramienta de software para la gestión y construcción de proyectos JAva creada por Jason van Zyl, de Sonatype, en 2002. Tiene un modelo de configuración de construcción basado en un formato XML. Maven utiliza un Project Object Model (POM),  para describir el proyecto de software a construir, sus dependencias de otros módulos y componentes externos, y el orden de construcción de los elementos. Viene con objetivos predefinidos para realizar ciertas tareas claramente definidas, como la compilación del código y su empaquetado. [Gracias wikipedia]

Con maven compilaremos todo sakai, así que es una herramienta muy importante.

Desde la página oficial de maven descargamos la versión 2.0.11. Una vez lo tengamos, descomprimimos el fichero que acabamos de bajarnos donde queramos instalarlo en mi caso va a ser en esta ruta ~/Trabajo/Sakai/maven después tendremos que ser consecuentes para establecer las variables de entorno, pero mientras nos acordemos como si lo queremos instalar en la ruta del tour de Francia.

Aquí va un aviso importante para navegantes,  al instalar sakai hay que modificar un buen puñadito de variables de entorno, si lo hacemos cada vez es un rollo bastante importante así que lo que haremos será escribir todas las variables en un fichero que se llama .bash_profile y que está en la raíz de nuestro usuario. Vamos a por ello pues. Tecleamos lo siguiente en la terminal:

$ open ~/.bash_profile

y en el fichero añadimos la variable de entorno MAVEN_HOME

export MAVEN_HOME=~/Trabajo/Sakai/maven

Y ahora nos queda añadirla al PATH para que así nuestro unix lo encuentre cuando vayamos a ejecutar maven desde la consola:

export PATH=$PATH:$MAVEN_HOME/bin

Una última pega tiene esto y es que sakai “a veces” se queda sin memoria así que hay que hay que incrementar las opciones de maven. Esto va un poquito a ojo (seguro quien sepa bien hacer esto le parecerá una abominación lo que acabo de escribir),  y estas es la configuración que a mi me funciona. Si se queda sin memoria es cuestión de añadir más:

export MAVEN_OPTS='-Xms256m -Xmx512m -XX:PermSize=64m -XX:MaxPermSize=128m'

En resumen, a nuestro fichero .bash_profile le hemos añadido las siguientes variables de entorno:

# VARIABLE DE ENTORNO DE MAVEN
export MAVEN_HOME=/Users/ada/Trabajo/Sakai/maven
export PATH=$PATH:$MAVEN_HOME/bin
export MAVEN_OPTS='-Xms256m -Xmx512m -XX:PermSize=64m -XX:MaxPermSize=128m'

Vamos a comprobar que todo vaya bien:

$ mvn --version
Apache Maven 2.2.0 (r788681; 2009-06-26 15:04:01+0200)
Java version: 1.6.0_17
Java home: /System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Home
Default locale: es_ES, platform encoding: MacRoman
OS name: "mac os x" version: "10.6.3" arch: "x86_64" Family: "mac"

Yuhu! Maven ya esta instalado a por el siguiente paso.

5. Instalar/Verificar que tenemos instalado Subversión

Como todo código para el que trabaje más de una persona, Sakai tamibén necesita un sistema de control de versiones, y Sakai hace uso de Svn.

Para comprobar que esta instalado escribimos en la terminal:

$ svn --version
svn, version 1.6.5 (r38866)
compiled Oct 16 2009, 02:54:10
 
Copyright (C) 2000-2009 CollabNet.
Subversion is open source software, see http://subversion.tigris.org/
This product includes software developed by CollabNet (http://www.Collab.Net/).

Y como está :) pasamos a la siguiente.

6. Descargar e instalar tomcat 5.5.17+ (estable)

Este paso es muy simple. Entramos en la web de tomcat, descargamos tomacat 5.5.29, que es la última estable que tienen los señores y señoras de apache. Descomprimimos el paquete (ojo, en una ruta razonable que luego hay que entrar). Entramos en la carpeta de tomcat/bin y le damos permisos de ejecución a los scripts:

sudo chmod ug+x *.sh

A continuación modificamos el fichero server.xml (se encuentra en /tomcat/conf/server.xml) y en la configuración del puerto de conexión, vamos a añadirle la codificación para carácteres utf-8.
Buscaremos, por tanto, la siguiente etiqueta:

Y añadiremos URIEncoding=”UTF-8″. Con lo que nos quedará así:

<Connector port="8080" maxHttpHeaderSize="8192"
maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
enableLookups="false" redirectPort="8443" acceptCount="100"
connectionTimeout="20000" disableUploadTimeout="true" URIEncoding="UTF-8" >

Inculimos las siguientes variables de entorno al fichero .bash_profile:

export CATALINA_HOME=~/sakai/tomcat
export PATH=$PATH:$CATALINA_HOME/bin
export JAVA_OPTS="-server -XX:+UseParallelGC -Xmx876m -XX:MaxPermSize=2160m -Djava.awt.headless=true"

7. Descargar y configurar el conector para Mysql

Descargamos la libreria que permitirá la comunicación entre sakai y la base de datos. Como tengo instalado un mysql 5.x, la libreria que tengo que bajar es la siguiente:

http://dev.mysql.com/downloads/connector/j/5.0.html

Extraemos el zip y copiamos el fichero mysql-connector-java-<version>-bin.jar en $CATALINA_HOME/common/lib, de este modo tomcat lo encontrará cuando despliege.

8. Descargar el código de sakai con svn

¡Por fin! Ya estamos más cerquita del final (por lo menos ya tenemos el código tras este paso). Descargamos el código de aquí:

$ svn checkout https://source.sakaiproject.org/svn/sakai/trunk/ trunk

9. Configurar el fichero de sakai.properties

Debemos crear una carpeta llamada sakai, dentro de $CATALINA_HOME, es decir en la carpeta del tomcat. Tenemos un ejemplo de properties en el código en trunk/reference/docs/sakai.properties, copiamos este fichero a la carpeta que acabamos de crear.

Editaremos ahora el fichero de propiedades para trabajar con sakai

Comentamos las líneas de configuración de  HSQLDB:

## HSQLDB settings - on by default
#vendor@org.sakaiproject.service.framework.sql.SqlService=hsqldb
#driverClassName@javax.sql.BaseDataSource=org.hsqldb.jdbcDriver
#hibernate.dialect=org.hibernate.dialect.HSQLDialect
#validationQuery@javax.sql.BaseDataSource=select 1 from SYSTEM_USERS
# two hsqldb storage options: first for in-memory (no persistence between runs), second for disk based
#url@javax.sql.BaseDataSource=jdbc:hsqldb:.
#url@javax.sql.BaseDataSource=jdbc:hsqldb:${sakai.home}/db/sakai.db

Indicamos el nombre del usuario y el de la base de datos y la contraseña para acceder:

username@javax.sql.BaseDataSource=sakai
password@javax.sql.BaseDataSource=tu_contraseña

Finalmente descomentamos los datos de configuración de mysql, y se quedará así:

## MySQL settings - make sure to alter as appropriate
vendor@org.sakaiproject.db.api.SqlService=mysql
driverClassName@javax.sql.BaseDataSource=com.mysql.jdbc.Driver
hibernate.dialect=org.hibernate.dialect.MySQLInnoDBDialect
url@javax.sql.BaseDataSource=jdbc:mysql://127.0.0.1:3306/sakai?useUnicode=true&amp;characterEncoding=UTF-8
validationQuery@javax.sql.BaseDataSource=select 1 from DUAL
defaultTransactionIsolationString@javax.sql.BaseDataSource=TRANSACTION_READ_COMMITTED

10. Crear el fichero de configuración de maven:

Ahora creamos en ~ un directorio oculto llamado .m2, aquí esta el repositorio donde maven desplegará. Dentro de este directorio creamos un fichero de configuración llamado settings.xml, con el siguiente contenido:

<settings xmlns="http://maven.apache.org/POM/4.0.0"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
                      http://maven.apache.org/xsd/settings-1.0.0.xsd">
  <profiles>
    <profile>
      <id>tomcat5x</id> 
      <activation>
        <activeByDefault>true</activeByDefault> 
      </activation>
      <properties>
        <appserver.id>tomcat5x</appserver.id> 
        <appserver.home>${env.CATALINA_HOME}</appserver.home> 
        <maven.tomcat.home>${env.CATALINA_HOME}</maven.tomcat.home> 
        <sakai.appserver.home>${env.CATALINA_HOME}</sakai.appserver.home> 
        <surefire.reportFormat>plain</surefire.reportFormat>
        <surefire.useFile>false</surefire.useFile>
      </properties>
    </profile>
  </profiles>
</settings>

¡Atención a la parametrización! Nos va a facilitar un montón la existencia, aunque ahora no lo podaís ver.

11. Utilizar maven para desplegar sakai

Esto ya casi casi esta. Abrimos una terminal y nos situamos donde tenemos el código fuente de sakai y tecleamos:

mvn clean install sakai:deploy -Dmaven.test.skip=true

Y ahora paciencia infinita, porque la primera vez que arranca tiene que descargarse un montón de librerias y tardará (mucho). Si sois valientes, después de lo dicho, le quitais el “-Dmaven.test.skip=true”, os hará todos los tests y tardará ni se sabe.

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 44 minutes 26 seconds
[INFO] Finished at: Fri May 21 13:42:51 CEST 2010
[INFO] Final Memory: 185M/344M
[INFO] ------------------------------------------------------------------------

Yuhu! Ya a compilado, ahora a arrancar el tomcat para poder probar nuestro flamante sakai nuevo, tras 44 minutos, vereís que mentirosa no soy.

~/tomcat/bin/startup
tail -f ~/tomcat/logs/catalina.out

Con estos dos comandos podremos arrancar tomcat y además ver el log, así podremos detectar si algo va mal. (Aunque como casi todos los logs es un poco marciano.)

Y por fin, veremos en la terminal la siguiente línea:

2010-06-08 16:18:13,274  INFO main org.apache.catalina.startup.Catalina – Server startup in 166240 ms

Y con esto y un bizcocho ya tenemos el trunk instalado.  Abrimos nuestro navegador favorito, escribimos: http://localhost:8080/portal y voilá  ya podemos ver la plataforma.

Pantalla de arranque de sakai

Pantalla de arranque de sakai

Posted in Programación, Sakai | Leave a comment