Apunts de Tecnologia

Els vídeotutorials de la deSymfony 2011

2012-03-05T21:16:00.000+01:00

PHP és un dels llenguatges més populars per a desenvolupar aplicacions i llocs web. La creació de llocs web acostuma a enfocar-se com la tria d'un gestor de continguts que ens proporcioni un sistema amistós per a fer pàgines i organitzar-les, i sense haver de preocupar-nos de detalls de baix nivell. En molts casos, ens permeten desenvolupar el lloc sense ni haver de conèixer PHP. Parlo, per exemple de Drupal i derivats, com OpenAtrium, o Joomla!... N'hi han molts.

Els Gestors de Contingut són extraordinàriament útils justament per al que estan fets: crear, mantenir, organitzar continguts, documents, imatges; organitzar-ne l'accés dels usuaris; llistes de correu; fòrums... tot allò per al que existeixi un mòdul disponible o que es pugui connectar al CMS i que no calgui modificar més enllà de les possibilitats de parametrització que ofereixi.

El problema ve quan els requeriments de l'aplicació web ja no són els relacionats amb la gestió de continguts. En aquest moment, el CMS ja no és útil, o només ho és marginalment. Aleshores cal atacar el desenvolupament de l'aplicació web d'una altre forma. Per descomptat que es pot encarar la construcció d'un lloc web creant des de zero, "from scratch", totes les pàgines del lloc.

Però en aquest cas segur que ens trobaríem que hem de reinventar la roda contínuament. Un enfoc més pràctic seria utilitzar un framework que ens proporcionés unes llibreries, una arquitectura, una estructura i unes capes i patrons ben definits per a desenvolupar el lloc. Encara serem nosaltres els responsables d'escriure les pàgines amb PHP i desenvolupar-ne els requeriments funcionals. Però ja no caldrà que reinventem la roda.

Estic parlant de frameworks com poden ser Spring, Ruby on Rails, ASP MVC... Tots ells es basen en el patró d'arquitectura MVC (Model View Controller).

Symfony és un dels framework MVC més populars per al llenguatge PHP.

Per a conèixer-lo millor podem revisar aquesta col·lecció de vídeos i tutorials que es van realitzar durant les jornades deSymfony 2011 a la Universitat Jaume I de Castelló, els passats 1,2 i 3 de juliol de 2011. Es tracta d'una recopilació excepcional que ens pot ajudar molt en la tasca d'iniciar-nos en l'ús de Symfony.

La DeSymphony és la major conferència sobre Symfony en castellà i la segona del món, en valor absolut, després de la Symfony Live que és la conferència oficial de Symfony.

Per a enguany també està prevista la celebració de jornades: la deSymfony 2012 els dies 15 i 16 de juny, a Castelló.

Tots els enllaços estan presos de la pàgina http://www.symfony.es/2011/07/06/desymfony-2011-todos-los-videos-y-presentaciones/. Els reprodueixo a continuació:

Els enllaços porten a les pàgines respectives de symfony.es, a les que està encastat el vídeo corresponent. Els vídeos estan allotjats a vimeo.

Vet aquí els enllaços:

Primer dia (1 de juliol de 2011):

Introducción a Symfony2 + Tutorial #1: Instalación y primeros pasos, Javier Eguiluz
Tutorial #2: El modelo. Doctrine2, Nacho Martín
Tutorial #3: La vista. Twig , Marcos Labad
Tutorial #4: Formularios y Seguridad, Javier López
Tutorial #5: Backend, Javier Eguiluz
Tutorial #6: Optimización, Assetic y Pruebas unitarias, Albert Jessurum
Mandango, un ODM ultra-rápido para PHP, MongoDB y Symfony2, Pablo Díez

Segon dia (2 de juliol de 2011):

Twig, cuando Django encontró a Symfony, Javier Eguiluz
Symfony 1, mi viejo amigo, José Antonio Pío
Microframework Silex, Nacho Martín
Rendimiento en aplicaciones web con Symfony2, Asier Marqués
Creación de aplicaciones móviles con Symfony2, Pablo Godel
Reduciendo el acoplamiento entre aplicaciones con RabbitMQ, Álvaro Videla
Symfony y los 3 millones de usuarios, nuestro día a día, Jordi Llonch
Deja los plugins en casa, ¡Habemus Bundles!, Albert Jessurum

Tercer dia (3 de juliol de 2011):

Entorno de desarrollo productivo, Pablo Godel
Introducción al desarrollo ágil, Ricardo Borillo

Criptografia de clau pública amb GnuPG

2012-02-29T23:26:00.003+01:00

Introducció

És molt possible que en alguna ocasió ens hagi sorgit la necessitat d'incrementar la seguretat en les nostres comunicacions per correu electrònic, o garantir l'autoria d'algun document, o la seva integritat.

Aquests són problemes antics i fa temps que se'ls ha donat respostes raonablement satisfactòries. Mai es pot garantir amb certesa absoluta la seguretat de les comunicacions, o l'autoria d'un document o la seva integritat, sobretot per la presència de factors humans. Però per la part del software, almenys es poden posar les coses prou difícils com per a que amb una tecnologia determinada no sigui possible vulnerar la seguretat en un temps finit i raonablement "curt".

Les comunicacions segures amb organismes oficials o amb entitats financeres passen per l'utilització de certificats digitals. En aquest cas, unes institucions internacionals, les autoritats de certificació, ens proporcionaran, per un preu, uns certificats digitals temporals de caràcter "universal" que vindran avalats per la confiança que hom té arreu del món en aquestes autoritats de certificació.

Aquesta solució que és inevitable seguir quan hom tracta amb organismes oficials, o en solucions de comerç electrònic, pot resultar excessiva, o no gens convenient, quan es tracta de garantir la privacitat personal.

¿I si volem restringir estrictament la privacitat de les comunicacions entre nosaltres i els nostres interlocutors sense la intervenció de terceres parts i sense que calgui posar-se contínuament d'acord amb passwords o claus secretes?

GnuPG

Una de les eines més populars per a poder fer comunicacions privades segures, signar documents garantint-ne la seva autoria o la seva integritat (que ningú l'ha modificat sense el nostre permís) és el PGP (Pretty Good Privacy). PGP té un equivalent en el programari lliure: el GPG o GnuPG (GNU Privacy Guard).

A Linux Ubuntu és possible que el tingueu instal·lat per defecte. En tot cas, des del Centre de Programari, o del Synaptic, es pot instal·lar (només cal cercar gpg) sense cap dificultat. Per a màquines Windows es pot instal·lar el Gpg4win que proporciona el gpg, eines per a gestionar claus, i integració amb l'explorador de windows, o amb Outlook.

Enigmail

En el món del programari lliure destacar entre d'altres que GnuPG s'integra amb el gestor de correu Mozilla Thunderbird mitjançant l'addon Enigmail.

Documentació

Si algú vol conèixer detalls en profunditat sobre GnuPG, la referència és Using the GNU Privacy Guard, també podem consultar The GNU Privacy Handbook (pdf), i en general, la pàgina de documentació de GnuPG.

Criptografia de clau pública

Prenguem contacte amb GnuPG. Primer de tot, crearé el parell de claus privada i pública sobre el que es construeix la seguretat de la criptografia de clau pública de GnuPG.

Vet aquí el plantejament de GnuPG: Nosaltres, i ningú més que nosaltres, som els guardians de la nostra clau privada que només coneixem nosaltres. No cal intercanviar cap password amb ningú.
La nostra clau pública, en canvi, la pot conèixer tothom.

Per a poder enviar un missatge xifrat a algú, ens cal la seva clau pública.
Per a poder dexifrar un missatge adreçat a nosaltres, ens cal la nostra clau privada.
Per a certificar que un missatge l'enviem nosaltres i que no ha estat alterat, el signem amb la nostra clau privada.
Per a verificar que un missatge l'ha enviat qui diu que l'ha enviat el verifiquem amb la clau pública de l'emissor.
Es pot signar (amb la nostra clau privada) i xifrar (amb la clau pública del destinatari) a l'hora un missatge que enviem.
Es pot verificar (amb la clau pública de l'emissor) i dexifrar (amb la nostra clau privada) a l'hora un missatge que rebem.

Tota l'estona estic parlant de "missatge" i hom podria pensar que em refereixo a missatges de correu electrònic. Però no és el cas. El "missatge" pot ser qualsevol fitxer que rebem per qualsevol via.

Criptografia de clau simètrica

Tanmateix, GnuPG també permet xifrar missatges mitjançant el sistema d'intercanvi de claus. Aquest sistema és el que es coneix com a criptografia de clau simètrica. És el que fem servir quan enviem o rebem un zip protegit amb password. Ens han de donar, o hem de donar, la clau per a poder-lo llegir.

Aleshores, WinZip o GnuPG? No hi ha una avantatge d'un sobre l'altre en quant a l'us de claus simètriques. L'algorisme de xifrat de clau simètrica que fa servir GnuPG per defecte és el CAST5. Que és superior a l'algorisme de xifrat que emprava originalment WinZip (zip 2.0). Tanmateix, les versions actuals de WinZIP fan servir l'algorisme de xifrat AES. Una altre eina a tenir en compte és OpenSSL. Es tracta de programari lliure per a, entre moltes d'altres opcions, xifrar i desxifrar missatges fent servir criptografia de clau simètrica.

Criptografia híbrida

En realitat, GnuPG combina el xifrat simètric amb el xifrat de clau pública. Els missatges enviats es xifren amb una clau simètrica de sessió (només per a aquell missatge), que a la seva vegada es xifrada amb la clau pública. Tot plegat, missatge i clau, s'empaqueta i s'envia junt. Aleshores el destinatari fa servir la clau privada per desxifrar la clau de sessió i, a continuació, fent servir la clau de sessió, desxifrar el missatge. GnuPG és doncs, de forma més precisa, un esquema de criptografia híbrida. El motiu de fer-ho així és que és menys costós computacionalment xifrar amb clau simètrica que amb asimètrica.

El criteri per a usar GnuPG, doncs, és per a emprar l'esquema de criptografia de clau pública en el que no cal intercanviar la clau simètrica. En criptografia de clau simètrica, el moment de l'intercanvi de la clau és el moment en que la comunicació és més vulnerable a un atac. En canvi, en la criptografia de clau pública, la vulnerabilitat depèn de la capacitat que tinguem de mantenir les claus privades en secret.

El programa gpg

Anem a tocar l'eina. Acabo d'instal·lar GnuPG amb synaptic. Faig un cop d'ull a les opcions de gpg:

albert@apolo:~$ gpg --help
gpg (GnuPG) 1.4.11
Copyright (C) 2010 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Home: ~/.gnupg
Algoritmes suportats:
Clau pública: RSA, RSA-E, RSA-S, ELG-E, DSA
Xifratge: 3DES, CAST5, BLOWFISH, AES, AES192, AES256, TWOFISH, CAMELLIA128,
CAMELLIA192, CAMELLIA256
Dispersió: MD5, SHA1, RIPEMD160, SHA256, SHA384, SHA512, SHA224
Compressió: No comprimit, ZIP, ZLIB, BZIP2

Sintaxi: gpg [opcions] [fitxers]
signa, comprova, xifra o desxifra
l'operació predeterminada depén de les dades introduïdes

Ordres:

-s, --sign [fitxer] crea una signatura
--clearsign [fitxer] crea una signatura en text clar
-b, --detach-sign crea una signatura separada
-e, --encrypt xifra dades
-c, --symmetric xifra només amb xifratge simètric
-d, --decrypt desxifra dades (predeterminat)
--verify verifica una signatura
--list-keys llista claus
--list-sigs llista claus i signatures
--check-sigs list and check key signatures
--fingerprint llista claus i empremtes digitals
-K, --list-secret-keys llista claus secretes
--gen-key genera un nou parell de claus
--delete-keys elimina claus de l'anell públic
--delete-secret-keys elimina claus de l'anell secret
--sign-key signa una clau
--lsign-key signa una clau localment
--edit-key signa o edita una clau
--gen-revoke genera un certificat de revocació
--export exporta claus
--send-keys exporta claus a un servidor de claus
--recv-keys importa claus d'un servidor de claus
--search-keys cerca claus en un servidor de claus
--refresh-keys actualitza totes les claus des d'un servidor de claus
--import importa/fon claus
--card-status print the card status
--card-edit change data on a card
--change-pin change a card's PIN
--update-trustdb actualitza la base de dades de confiança
--print-md algo [fitxers]
imprimeix resums de missatges

Opcions:

-a, --armor crea eixida amb armadura ascii
-r, --recipient NOM xifra per a NOM
-u, --local-user usa aquest id per a signar o desxifrar
-z N nivell de compressió N (0 no comprimeix)
--textmode usa el mode de text canònic
-o, --output fitxer d'eixida
-v, --verbose detall
-n, --dry-run no fa cap canvi
-i, --interactive pregunta abans de sobreescriure
--openpgp use strict OpenPGP behavior
--pgp2 generate PGP 2.x compatible messages

(En la pàgina del man hi ha una llista completa d'ordres i d'opcions)

Exemples:

-se -r Bob [fitxer] signa i xifra per a l'usuari Bob
--clearsign [fitxer] crea una signatura en text clar
--detach-sign [fitxer] crea una signatura separada
--list-keys [noms] mostra claus
--fingerprint [noms] mostra empremtes digitals

Si us plau, informeu sobre els errors a <gnupg-bugs@gnu.org>.

Tanmateix, amb --help no s'obtenen totes les opcions. Per a obtenir un llistat de totes les opcions de gpg, cal consultar el manual: a un terminal fem man pgp.

Generar claus

El primer de tot: Genero les claus amb gpg --gen-key. Fixem-nos com ens permet seleccionar el tipus de clau, el temps de validesa (he triat 1 any), un ID que es construeix amb el nom i cognoms, adreça electrònica i un comentari, i ens demana també un password per xifrar la clau privada. Aquesta password ens la demanarà sempre que ens calgui la clau privada. El password NO és la clau privada. Però ens caldrà el password per a poder-la utilitzar. Trobem novament una clau simètrica per protegir, en aquest cas, la clau privada; però aquí no hem d'intercanviar la password amb ningú. Al contrari. El que cal és que ningú més que nosaltres conegui aquest password.

albert@athena:~$ gpg --gen-key

This is free software: you are free to change and redistribute it.

There is NO WARRANTY, to the extent permitted by law.

gpg: directory `/home/albert/.gnupg' created

gpg: s'ha creat el nou fitxer d'opcions «/home/albert/.gnupg/gpg.conf»

gpg: AVÍS: les opcions en «/home/albert/.gnupg/gpg.conf» encara no estan actives durant aquesta execució

gpg: s'ha creat l'anell «/home/albert/.gnupg/secring.gpg»

gpg: s'ha creat l'anell «/home/albert/.gnupg/pubring.gpg»

Seleccioneu quin tipus de clau voleu:

(1) RSA and RSA (default)

(2) DSA and Elgamal

(3) DSA (només signar)

(4) RSA (només signar)

La vostra selecció? 1

RSA keys may be between 1024 and 4096 bits long.

What keysize do you want? (2048) 4096

La grandària sol·licitada és 4096 bits

Especifiqueu el temps de validesa de la clau.

0 = la clau no caduca

<n> = la clau caduca als n dies

<n>w = la clau caduca a les n setmanes

<n>m = la clau caduca als n mesos

<n>y = la clau caduca als n anys

Indiqueu la validesa de la clau (0) 1y

Key expires at dj 21 feb 2013 21:30:51 CET

Is this correct? (y/N) y

You need a user ID to identify your key; the software constructs the user ID

from the Real Name, Comment and Email Address in this form:

"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>"

Nom i cognoms: Albert Baranguer Codina

Adreça electrònica: abaranguer@gmail.com

Comentari: clau personal

Heu triat l'identificador d'usuari:

"Albert Baranguer Codina (clau personal) <abaranguer@gmail.com>"

Canvia (N)om, (C)omentari, (E)mail o (O) d'acord / (X) ix o

Cal una contrasenya per a protegir la clau secreta.

Cal generar molts bits aleatòriament. És bona idea fer alguna altra cosa

(teclejar, moure el ratolí, usar els discos) durant la generació de

nombres primers; açò dóna oportunitat al generador de nombres aleatoris

d'aconseguir prou entropia.

..+++++

......+++++

Cal generar molts bits aleatòriament. És bona idea fer alguna altra cosa

(teclejar, moure el ratolí, usar els discos) durant la generació de

nombres primers; açò dóna oportunitat al generador de nombres aleatoris

d'aconseguir prou entropia.

...................................+++++

..............+++++

gpg: /home/albert/.gnupg/trustdb.gpg: s'ha creat la base de dades de confiança

gpg: key 7FCC9B65 marked as ultimately trusted

s'han creat i signat les claus pública i secreta.

gpg: s'està comprovant la base de dades de confiança

gpg: 3 marginal(s) needed, 1 complete(s) needed, PGP trust model

gpg: depth: 0 valid: 1 signed: 0 trust: 0-, 0q, 0n, 0m, 0f, 1u

gpg: la pròxima comprovació de la base de dades de confiança serà el 2013-02-21

pub 4096R/7FCC9B65 2012-02-22 [expires: 2013-02-21]

Key fingerprint = *********** demana'm el fingerprint! ***************

uid Albert Baranguer Codina (clau personal) <abaranguer@gmail.com>

sub 4096R/B092F31D 2012-02-22 [expires: 2013-02-21]

albert@athena:~$

La meva clau pública!

Obtinc la clau pública, és el bloc en negreta:

albert@athena:~$ gpg --armor --output public-key.asc --export abaranguer

albert@athena:~$ cat public-key.asc

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v1.4.11 (GNU/Linux)
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=+LAQ
-----END PGP PUBLIC KEY BLOCK-----

Si algú em vol enviar missatges xifrats amb GnuPG, ja pot fer-ho! ;-)

Fingerprint

Tothom que em vulgui enviar missatges xifrats haurà de tenir la meva clau pública. Ara bé, si l'agafa de la web com pot estar-ne segur que és de veritat la meva clau pública? Haurà de verificar-ne el "fingerprint". L'empremta dactilar. Quan he generat la clau una de les línies m'ha informat del fingerprint de la clau:

pub 4096R/7FCC9B65 2012-02-22 [expires: 2013-02-21]

Key fingerprint = *********** demana'm el fingerprint! ***************

Que he decidit no publicar a la web...

Aleshores, algú que rebi la meva clau pública hauria de posar-se en contacte amb mi d'alguna forma segura per verificar que el fingerprint de la clau que té correspon amb el fingerprint que jo posseeixo. Si coincideixen l'usuari podrà la confiar que ha rebut la meva clau pública.

Suposant que copia la clau pública a un fitxer de text anomenat abaranguer@gmail.com.pub.asc l'usuari haurà d'importar la meva clau pública al seu clauer.

Llistar les claus

... i podria començar per verificar les claus que són al clauer.

albert@apolo:~/Documents$ gpg --list-key
/home/albert/.gnupg/pubring.gpg
-------------------------------
pub 4096R/6E28AAB8 2012-02-26 [expires: 2017-02-24]
uid Albert Baranguer Codina (Clau Personal 2) <albert.baranguer@josoc.cat>
sub 4096R/3B954851 2012-02-26 [expires: 2017-02-24]

albert@apolo:~/Documents$

Només hi té la seva clau. El que ha de fer és...

Importar una clau

Tinc abaranguer@gmail.com.pub.asc a la carpeta Documents i faig:

albert@apolo:~/Documents$ gpg --import abaranguer@gmail.com.pub.asc
gpg: key 7FCC9B65: public key "Albert Baranguer Codina (clau personal) <abaranguer@gmail.com>" imported
gpg: Nombre total processat: 1
gpg: importades: 1 (RSA: 1)
albert@apolo:~/Documents$

Verifico que he importat la clau

albert@apolo:~/Documents$ gpg --list-key
/home/albert/.gnupg/pubring.gpg
-------------------------------
pub 4096R/6E28AAB8 2012-02-26 [expires: 2017-02-24]
uid Albert Baranguer Codina (Clau Personal 2) <albert.baranguer@josoc.cat>
sub 4096R/3B954851 2012-02-26 [expires: 2017-02-24]

pub 4096R/7FCC9B65 2012-02-22 [expires: 2013-02-21]
uid Albert Baranguer Codina (clau personal) <abaranguer@gmail.com>
sub 4096R/B092F31D 2012-02-22 [expires: 2013-02-21]

albert@apolo:~/Documents$

Obtenir el fingerprint

Quin és el fingerprint de la clau que acabo d'importar?

albert@apolo:~/Documents$ gpg --fingerprint
/home/albert/.gnupg/pubring.gpg
-------------------------------
pub 4096R/6E28AAB8 2012-02-26 [expires: 2017-02-24]
Key fingerprint = ************* fingerprint 1 *************
uid Albert Baranguer Codina (Clau Personal 2) <albert.baranguer@josoc.cat>
sub 4096R/3B954851 2012-02-26 [expires: 2017-02-24]

pub 4096R/7FCC9B65 2012-02-22 [expires: 2013-02-21]
Key fingerprint = ******* fingerprint clau importada ******
uid Albert Baranguer Codina (clau personal) <abaranguer@gmail.com>
sub 4096R/B092F31D 2012-02-22 [expires: 2013-02-21]

O bé una de sola

albert@apolo:~/Documents$ gpg --fingerprint abaranguer@gmail.com
pub 4096R/7FCC9B65 2012-02-22 [expires: 2013-02-21]
Key fingerprint = ******* fingerprint clau importada ******
uid Albert Baranguer Codina (clau personal) <abaranguer@gmail.com>
sub 4096R/B092F31D 2012-02-22 [expires: 2013-02-21]

Servidors de claus

Recapitulem: fins ara he creat un parell de claus, una de privada que només conec jo i una de pública que he publicat a la web. Tothom que vulgui enviar-me missatges pot fer servir la clau pública per xifrar-los. Si vol estar-ne segur que la clau pública "és bona", hauria de posar-se en contacte amb mi per a verificar-ne el fingerprint.

Hi ha una altre opció per a fer això: puc publicar la clau a un servidor de claus. Els servidors de claus emmagatzemen i permeten examinar claus públiques. A més els servidors de claus repliquen la informació entre ells, de forma que quan hom publica la seva clau a un servidor, en pocs dies aquesta clau és disponible a la resta de servidors.

El camí contrari, "despublicar" del keyserver, demana pujar al servidor el certificat de revocació de la clau. El certificat de revocació el podem generar amb el mateix GnuPG. Es recomana generar el certificat just al mateix moment en que hom crea el parell de claus.

Si hagués publicat la clau a un keyserver ara, en comptes de publicar la clau a la web, en tindria prou amb publicar-ne l'ID. L'ID de la clau és aquest número que he obtingut al generar.

pub 4096R/7FCC9B65 2012-02-22 [expires: 2013-02-21]

Aleshores qualsevol usuari podria utilitzar l'ID per cercar la clau i descarregar-se-la dels keyservers.

I un usuari amb qui no ens coneixem de res, perquè se n'hauria de refiar d'aquesta clau descarregada d'un keyserver?

Xarxa de confiança

Per a poder respondre a aquesta pregunta cal explicar primer que quan un usuari rep una clau pública, en verifica el fingerprint i te confiança en el propietari, aleshores pot signar la clau pública rebuda amb la seva pròpia clau privada. Aquesta clau pública té un plus afegit de confiança: un usuari en certifica la seva validesa. Aquesta clau pública signada es podria passar a un altre usuari que, en cas de verificar el fingerprint o, senzillament, perquè confia en l'usuari que ha signat la clau podria, a la seva vegada, signar ell també la clau.

Cada cop que algú signa la nostra clau pública està certificant que la clau és de confiança. Com més signatures té la clau, vol dir que més gent certifica que "és bona". A més, cadascun d'aquest usuaris pot tenir la seva pròpia clau pública amb signatures d'altres usuaris. Aquesta xarxa de signatures de la que participa la nostra clau és la seva "xarxa de confiança" (web of trust).

Tanmateix, hom podria desconfiar d'algunes de les claus de la xarxa de confiança. En aquest cas GnuPG permet afegir un indicador de "confiança" (mireu també aquí) sobre les diferents persones que han signat. Des del "desconegut", passant pel "cap confiança", "hi confio" fins al "confio com si fos jo mateix". En tot cas, aquest indicador és d'us personal i no es posa a la clau.

La resposta, doncs, a la pregunta de perquè un usuari se n'hauria de refiar de la clau descarregada del key server és que no té perquè fer-ho, però pot pensar que una clau pública que estigui signada per uns quants usuaris, o que pertany o toca a la seva xarxa de confiança pot ser, raonablement, de confiança.

Festa de firmes!

Els grups d'usuaris de PGP / GnuPG convoquen de tant en tant les "Festes de Firmes" (key signing party). Que es un esdeveniment en que els participants s'intercanvien les seves fingerprint després d'haver verificat mutuament les identitats, per exemple amb el DNI, de forma que, en acabar l'acte, amb els fingerprint de les claus públiques d'altres participants, les descarreguen del keyserver, en verifiquen els fingerprint, les signen i les redifonen. Es tracta d'una forma lúdica d'ampliar la xarxa de confiança (podríem veure-ho com una xarxa social més, en definitiva).

En to cas, podem fer servir GnuPG sense que calgui la xarxa de confiança.

Signar

Un cop explicats aquests conceptes, passem a qüestions més pràctiqes

Com signo un document? Vaig a generar un document de prova (loremipsum.txt) en que hi posaré un paràgraf del Lorem ipsum (el genero amb aquesta web: http://ca.lipsum.com/)

Per a signar-lo amb la clau privada faig

gpg --sign loremipsum.txt

Observem que gpg ens demana la password de la clau privada. El resultat eś el fitxer xifrat amb extensió loremipsum.txt.gpg.

Si volgués que el fitxer fos ilegible i amb un altre nom faria:

gpg --armor --output signat.txt --sign loremipsum.txt

També podria voler que el text original es pogués llegir "en clar", i que la signatura estigués separada en el mateix fitxer. Aleshores faria

gpg --output signat.2.txt --clearsign loremipsum.txt

Però si el document original amb el missatge no admetés la inclusió de cap signatura, el que es podria fer és posar la signatura en un fitxer signatura.txt apart. A més el vull fer legible. Ho faig així:

gpg --armor --output signatura.txt --detach-sign loremipsum.txt

Depenent del cas, enviaré el document signat, o la signatura i el document en fitxers separats, al seu destinatari. Aquest, un cop rebi el document signat, el verificarà amb la meva clau pública.

Verificar la signatura

El receptor del missatge podria verificar amb

gpg --verify loremipsum.txt.gpg

( o amb signat.txt, o signat.2.txt )

En aquest cas obtindrem un missatge

albert@apolo:~/Documents$ gpg --verify signatura.txt loremipsum.txt
gpg: Signature made dt 28 feb 2012 22:55:35 CET using RSA key ID 7FCC9B65
gpg: Good signature from "Albert Baranguer Codina (Clau Personal) <abaranguer@gmail.com>"

o bé, si venen per separat:

gpg --verify signatura.txt loremipsum.txt

Primer ha d'anar la signatura, i després el document que s'ha signat. En cas de posar-los en l'ordre invers, obtindrem un missatge d'error:

albert@apolo:~/Documents$ gpg --verify loremipsum.txt signatura.txt
gpg: no s'han trobat dades OpenPGP vàlides.
gpg: no s'ha pogut verificar la signatura.
Recordeu que el fitxer de signatura (.sig o .asc)
ha de ser el primer que figure en la línia d'ordres.

Xifrar un missatge

Per a fer la prova, enviaré  el loremipsum.txt xifrat a l'usuari unaltrecompte@servidor.com, del qual tinc la clau pública.

Tinc algunes claus públiques més al clauer. Per tant he de triar la del destinatari. Ho faig amb l'opció --recipient i l'ID de la clau.

Vet aquí:

albert@athena:~/Documents$ gpg --armor --output xifrat.txt --recipient 6E28AAB8 --encrypt loremipsum.txt
gpg: 3B954851: There is no assurance this key belongs to the named user

pub 4096R/3B954851 2012-02-26 Albert Baranguer Codina (Clau Personal 2) <unaltrecompte@servidor.com>
Empremta digital de la clau primària: xxxx xxxx xxxx xxxx xxxx  xxxx xxxx xxxx xxxx xxxx
Empremta digital de la subclau: xxxx xxxx xxxx xxxx xxxx  xxxx xxxx xxxx xxxx xxxx

It is NOT certain that the key belongs to the person named
in the user ID. If you *really* know what you are doing,
you may answer the next question with yes.

Use this key anyway? (y/N) y

Les claus públiques del meu clauer no les he signat ni tenen cap signatura de ningú de "confiança absoluta", per tant rebo un missatge d'advertència. Podria signar la clau i marcar el destinatari com "de confiança absoluta, com si fos jo mateix", (de fet, ho soc! ;-) de forma que m'estalviaria aquest missatge.

Signar una clau pública

Primer miro les claus del clauer

albert@athena:~$ gpg --list-keys
/home/albert/.gnupg/pubring.gpg
-------------------------------
pub 4096R/7FCC9B65 2012-02-22 [expires: 2013-02-21]
uid Albert Baranguer Codina (clau personal) <abaranguer@gmail.com>
sub 4096R/B092F31D 2012-02-22 [expires: 2013-02-21]

pub 2048R/D826822A 2012-02-23 [expires: 2017-02-21]
uid Serveis TIC i Programari Lliure <stsoftlliure@gmail.com>
sub 2048R/9D8D4AA0 2012-02-23 [expires: 2017-02-21]

pub 4096R/6E28AAB8 2012-02-26 [expires: 2017-02-24]
uid Albert Baranguer Codina (Clau Personal 2) <unaltrecompte@servidor.com>
sub 4096R/3B954851 2012-02-26 [expires: 2017-02-24]

I em fixo en els seus ID. Abans de signar-les hauria de comprovar-ne els fingerprint per estar-ne segur de la seva autenticitat. En aquest cas ho considero fet. Totes són claus de prova.

Per tant, puc passar a signar la clau corresponent

albert@athena:~$ gpg --sign-key 6E28AAB8

pub 4096R/6E28AAB8 created: 2012-02-26 expires: 2017-02-24 usage: SC
trust: desconeguda validity: desconeguda
sub 4096R/3B954851 created: 2012-02-26 expires: 2017-02-24 usage: E
[ unknown] (1). Albert Baranguer Codina (Clau Personal 2) <unaltrecompte@servidor.com>

pub 4096R/6E28AAB8 created: 2012-02-26 expires: 2017-02-24 usage: SC
trust: desconeguda validity: desconeguda
Empremta digital de la clau primària: C6EC 5EAF 31BE C8D9 6644 200F 1849 3E7D 6E28 AAB8

Albert Baranguer Codina (Clau Personal 2) <unaltrecompte@servidor.com>

Aquesta clau caducarà el 2017-02-24.
Are you sure that you want to sign this key with your
key "Albert Baranguer Codina (clau personal) <abaranguer@gmail.com>" (7FCC9B65)

Really sign? (y/N) y

Cal una contrasenya per desblocar la clau secreta de
l'usuari: «Albert Baranguer Codina (clau personal) <abaranguer@gmail.com>» "
4096-bit RSA key, ID 7FCC9B65, created 2012-02-22

gpg: gpg-agent no està disponible en aquesta sessió

albert@athena:~$

Veifico que realment ha signat

albert@athena:~$ gpg --list-sigs
gpg: s'està comprovant la base de dades de confiança
gpg: 3 marginal(s) needed, 1 complete(s) needed, PGP trust model
gpg: depth: 0 valid: 1 signed: 2 trust: 0-, 0q, 0n, 0m, 0f, 1u
gpg: depth: 1 valid: 2 signed: 0 trust: 2-, 0q, 0n, 0m, 0f, 0u
gpg: la pròxima comprovació de la base de dades de confiança serà el 2013-02-21
/home/albert/.gnupg/pubring.gpg
-------------------------------
pub 4096R/7FCC9B65 2012-02-22 [expires: 2013-02-21]
uid Albert Baranguer Codina (clau personal) <abaranguer@gmail.com>
sig 3 7FCC9B65 2012-02-22 Albert Baranguer Codina (clau personal) <abaranguer@gmail.com>
sub 4096R/B092F31D 2012-02-22 [expires: 2013-02-21]
sig 7FCC9B65 2012-02-22 Albert Baranguer Codina (clau personal) <abaranguer@gmail.com>

pub 2048R/D826822A 2012-02-23 [expires: 2017-02-21]
uid Serveis TIC i Programari Lliure <stsoftlliure@gmail.com>
sig 3 D826822A 2012-02-23 Serveis TIC i Programari Lliure <stsoftlliure@gmail.com>
sub 2048R/9D8D4AA0 2012-02-23 [expires: 2017-02-21]
sig D826822A 2012-02-23 Serveis TIC i Programari Lliure <stsoftlliure@gmail.com>

pub 4096R/6E28AAB8 2012-02-26 [expires: 2017-02-24]
uid Albert Baranguer Codina (Clau Personal 2) <unaltrecompte@servidor.com>
sig 3 6E28AAB8 2012-02-26 Albert Baranguer Codina (Clau Personal 2) <unaltrecompte@servidor.com>
sig 7FCC9B65 2012-02-29 Albert Baranguer Codina (clau personal) <abaranguer@gmail.com>
sub 4096R/3B954851 2012-02-26 [expires: 2017-02-24]
sig 6E28AAB8 2012-02-26 Albert Baranguer Codina (Clau Personal 2) <unaltrecompte@servidor.comt>

albert@athena:~$

Aquí podem comprovar que tota signatura públic té, almenys, una signatura, que,es la de la seva parella clau privada. El compte unaltrecompte@servidor.com té, doncs dues signatures, la de la seva parella privada i la que li acabo de posar.

Ara que tinc la clau pública de unaltrecompte@servicor.com signada, repeteixo el xifrat del loreipsum.txt

albert@athena:/media/ADATA UFD/docs$ gpg --armor --output xifrat.2.txt --recipient 6E28AAB8 --encrypt loremipsum.txt
albert@athena:/media/ADATA UFD/docs$

El resultat és que obtinc el fitxer xifrat.2.txt netament, sense cap missatge d'advertència.

Xifrar i signar un missatge

Però, i si el destinatari volgués tenir la certesa que el fitxer l'he enviat jo? Ben mirat, algú em podria haver suplantat i enviar el missatge enlloc meu. El que cal fer, per a eliminar aquest dubte, és signar i xifrar a l'hora el document.

A l'exemple, faig:

albert@athena:/media/ADATA UFD/docs$ gpg --armor --output xifrat.4.txt --recipient 6E28AAB8 --sign --encrypt loremipsum.txt

Cal una contrasenya per desblocar la clau secreta de
l'usuari: «Albert Baranguer Codina (clau personal) <abaranguer@gmail.com>» "
4096-bit RSA key, ID 7FCC9B65, created 2012-02-22

gpg: gpg-agent no està disponible en aquesta sessió
albert@athena:/media/ADATA UFD/docs$

i obtinc el fitxer xifrat i signat xifrat4.txt. Com sempre que cal fer alguna acció amb la clau privada, gpg m'ha demanat la password per a poder fer-la servir.

I què hauria passat si la clau no hagués estat signada?

albert@athena:~/Documents$ gpg --armor --output xifrat.2.txt --recipient 6E28AAB8 --sign --encrypt loremipsum.txt

Cal una contrasenya per desblocar la clau secreta de
l'usuari: «Albert Baranguer Codina (clau personal) <abaranguer@gmail.com>» "
4096-bit RSA key, ID 7FCC9B65, created 2012-02-22

gpg: gpg-agent no està disponible en aquesta sessió
gpg: 3B954851: There is no assurance this key belongs to the named user

pub 4096R/3B954851 2012-02-26 Albert Baranguer Codina (Clau Personal 2) <unaltrecompte@servidor.com>
Empremta digital de la clau primària: xxxx xxxx xxxx xxxx xxxx  xxxx xxxx xxxx xxxx xxxx
Empremta digital de la subclau: xxxx xxxx xxxx xxxx xxxx  xxxx xxxx xxxx xxxx xxxx

It is NOT certain that the key belongs to the person named
in the user ID. If you *really* know what you are doing,
you may answer the next question with yes.

Use this key anyway? (y/N) y
albert@athena:~/Documents$

Primer em demana la password de la clau privada. A continuació m'adverteix que la clau pública del destinatari no està signada. El resultat, en tot cas, és el fitxer xifrat.2.txt

Desxifrar

Ara tinc uns quants fitxers xifrats que només podrà dexifrar unaltrecompter@servidor.com.

És el més senzill de tot: dexifrar és l'opció per defecte de gpg, per tant, n'hi ha prou amb fer...

albert@apolo:/media/ADATA UFD/docs$ gpg xifrat.txt

Cal una contrasenya per desblocar la clau secreta de
l'usuari: «Albert Baranguer Codina (Clau Personal 2) <unaltrecompte@servidor.com>» "
4096-bit RSA key, ID 3B954851, created 2012-02-26 (main key ID 6E28AAB8)

gpg: gpg-agent no està disponible en aquesta sessió
gpg: encrypted with 4096-bit RSA key, ID 3B954851, created 2012-02-26
"Albert Baranguer Codina (Clau Personal 2) <unaltrecompte@servidor.com>"
gpg: xifrat.txt: el sufix és desconegut
Introduïu el nou nom del fitxer [loremipsum.txt]: loremipsum.decrypt.txt
albert@apolo:/media/ADATA UFD/docs$

Com que per a dexifrar cal la clau privada, el gpg demana el password corresponent.

En examinar loremipsum.decrypt.txt obtinc, com era d'esperar el paràgraf de Lorem Ipsum original.

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque dignissim lobortis auctor. Nunc sem sapien, egestas eu dignissim non, molestie sit amet mi. In diam lacus, fermentum et mollis quis, pellentesque id enim. Nullam pretium, dolor non malesuada viverra, eros odio convallis arcu, eu tincidunt libero purus sit amet purus. Praesent eu aliquet nunc. Sed vitae augue lacus. Duis fermentum purus sed ligula malesuada nec ornare orci posuere. Etiam ac facilisis turpis.

Per acabar

En el post dedicat a gpg he fet un repàs dels principals conceptes que cal conèixer per a utilitzar GnuPG. He esmentat altres eines relacionades, com Enigmail. He distingit entre criptografia de clau simètrica, de clau pública, i híbrida. També he parlat de les xarxes de confiança que es poden implementar els intercanvis de claus públiques de GnuPG. He presentat les accions principals que es poden realitzar amb GnuPG, que són signar, xifrar, verificar i dexifrar.

En cap cas he pretès realitzar una anàlisi exhaustiva de l'eina. Hi han molts i bons manuals fets que acompleixen aquesta missió i n'he citat alguns.

Finalment, el resultat d'aquest post és que penjaré la meva clau pública a la web. Per si algú prefereix entrar en contacte amb Serveis TIC i Programari Lliure de forma privada.

Una aproximació a Google App Engine. Com desenvolupar al núvol de Google.

2011-12-27T19:09:00.004+01:00

Google App Engine és la plataforma que ofereix Google i en la que es poden executar aplicacions web pròpies desenvolupades en Java, i d'altres llenguatges, de forma gratuita fins a un cert nivell de tràfic o recursos. L'interès de Google App Engine és que a l'estar-ne integrat, permet aprofitar els serveis de la "plataforma Google"i, a més, es disposa d'una API que permet accedir a aquests serveis.

Només cal tenir un compte a Google i registrar-se amb Google App Engine per a poder accedir a aquest servei de plataforma (Platform as a Service, o PaaS) i poder desenvolupar aplicacions en el núvol personal a Google.

Google App Engine és, doncs, una plataforma de cloud computing en la que podrem desplegar aplicacions web (per exemple, un CMS com Vosao) i disposarem d'APIS que permetran l'autenticacio , amb la resta de serveis que tinguem a Google, com Docs,o enviar correus amb GMail, o

No confondre Google App Engine amb Google Apps (amb s). Aquest últim ve a ser la versió "personalitzada" i depenent del grau de personalització, de pagament, dels serveis de Google . Per cert, Apps també pot ser considerat una plataforma de desenvolupament. Google Apps Script permet crear macros per automatitzar tasques amb Javascript. Poso en cartera un post per parlar d'Apps i de les seves macros.

Però tornem a l'App Engine. Hi han restriccions que cal tenir en compte. Entre d'altres: Només es pot fer servir un subconjunt de les classes del JRE estàndard, la "llista blanca de classes de JRE"; les aplicacions no poden crear fils (Thread); Els processos de servidor en resposta a peticions no poden trigar més de 30s; només es pot executar codi en resposta a peticions rebudes per HTTP; les aplicacions estan limitades pels frameworks que imposa Google i, per exemple, es pot consultar, afegir, modificar i esborrar dades de la base de dades NO-Relacional BigTable que proporciona Google App Engine, però no es poden fer servir bases de dades relacionals com MySQL.

A la wikipedia podem trobar una bona descripció del Google App Engine. En tot cas, les especificacions i restriccions depenen de Google.

El que m'interessa a mi és com funciona des del punt de vista del desenvolupador. Res millor que seguir els demos de l'SDK de Google App Engine (GAE).

Cal el JDK 1.6 com a mínim.
L'SDK de Google App Engine per Java i la documentació (http://code.google.com/intl/ca-ES/appengine/downloads.html)

Un cop descarregat i instal·lat tot aquest material, em dirigeixo a la java Getting Started Guide, per a compilar les proves faré servir Apache Ant.

En aquest moment tinc a /home/albert la carpeta
appengine-java-sdk
Que he renombrat eliminant-ne el sufix amb el número de versió seguint les indicacions de la guia; i la carpeta
google-appengine-docs
que conté la documentació i que també he renombrat eliminat-ne el sufix amb la data de versió.

Ara puc provar l'aplicació Guestbook que va amb les demos de l'appengine, fent
./appengine-java-sdk/bin/dev_appserver.sh appengine-java-sdk/demos/guestbook/war
des de la carpeta /home/albert

L'aplicació engega:

albert@athena:~$ ./appengine-java-sdk/bin/dev_appserver.sh appengine-java-sdk/demos/guestbook/war
31/12/2011 19:32:49 com.google.apphosting.utils.jetty.JettyLogger info
INFO: Logging to JettyLogger(null) via com.google.apphosting.utils.jetty.JettyLogger
31/12/2011 19:32:50 com.google.apphosting.utils.config.AppEngineWebXmlReader readAppEngineWebXml
INFO: Successfully processed /home/albert/appengine-java-sdk/demos/guestbook/war/WEB-INF/appengine-web.xml
31/12/2011 19:32:51 com.google.apphosting.utils.config.AbstractConfigXmlReader readConfigXml
INFO: Successfully processed /home/albert/appengine-java-sdk/demos/guestbook/war/WEB-INF/web.xml
31/12/2011 20:33:08 com.google.appengine.tools.development.DevAppServerImpl start
INFO: The server is running at http://localhost:8080/
31/12/2011 20:33:09 com.google.appengine.tools.development.DevAppServerImpl start
INFO: The admin console is running at http://localhost:8080/_ah/admin
31/12/2011 20:34:04 com.google.appengine.tools.development.LocalResourceFileServlet doGet
WARNING: No file found for: /favicon.ico

I fent http://localhost:8080

Puc deixar alguns missatges de prova:

També podem fer un cop d'ull a la consola d'administració, a http://localhost:8080/_ah/admin

Podem examinar el visor de dades El datastore viewer, o es pot examinar la finestra XMPP per als missatges de xats, el correu electrònic associat... En particular, al Datastore Viewer podrem examinar els missatges que ja hem afegit.

Com ho fa? a la carpeta appengine-java-sdk/demos/guestbook/war trobem el codi font de l'aplicació.

En un primer cop d'ull ens adonem que es tracta d'una aplicació web java gairebé estàndar: hi trobem jsp i css i una carpeta WEB-INF amb els habituals sub-carpetes classes i lib. A més també hi trobo el web.xml de les aplicacions web i, como a variació sobre el estàndar, un document appengine-web.xml.

En aquest cas, appengine-web.xml només informa de la versió de l'aplicació i del fitxer de propietats del sistema de logs. Sobre aquest últim, dir que el sistema de logs del GAE és similar al que hom implementa amb log4j.

Vet aquí l'appengine-web.xml

<appengine-web-app xmlns="http://appengine.google.com/ns/1.0">

<application/>
<version>1</version>
<system-properties>
<property name="java.util.logging.config.file" value="WEB-INF/logging.properties"/>
</system-properties>

</appengine-web-app>

A continuació, examino la resta del codi.

Primer de tot, la pàgina guestbook.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ page import="java.util.List" %>
<%@ page import="com.google.appengine.api.users.User" %>
<%@ page import="com.google.appengine.api.users.UserService" %>
<%@ page import="com.google.appengine.api.users.UserServiceFactory" %>
<%@ page import="com.google.appengine.api.datastore.DatastoreServiceFactory" %>
<%@ page import="com.google.appengine.api.datastore.DatastoreService" %>
<%@ page import="com.google.appengine.api.datastore.Query" %>
<%@ page import="com.google.appengine.api.datastore.Entity" %>
<%@ page import="com.google.appengine.api.datastore.FetchOptions" %>
<%@ page import="com.google.appengine.api.datastore.Key" %>
<%@ page import="com.google.appengine.api.datastore.KeyFactory" %>

<html>
<head>
<link type="text/css" rel="stylesheet" href="/stylesheets/main.css" />
</head>

<body>

<%
String guestbookName = request.getParameter("guestbookName");
if (guestbookName == null) {
guestbookName = "default";
}
UserService userService = UserServiceFactory.getUserService();
User user = userService.getCurrentUser();
if (user != null) {
%>
<p>Hello, <%= user.getNickname() %>! (You can
<a href="<%= userService.createLogoutURL(request.getRequestURI()) %>">sign out</a>.)</p>
<%
} else {
%>
<p>Hello!
<a href="<%= userService.createLoginURL(request.getRequestURI()) %>">Sign in</a>
to include your name with greetings you post.</p>
<%
}
%>

<%
DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
Key guestbookKey = KeyFactory.createKey("Guestbook", guestbookName);
// Run an ancestor query to ensure we see the most up-to-date
// view of the Greetings belonging to the selected Guestbook.
Query query = new Query("Greeting", guestbookKey).addSort("date", Query.SortDirection.DESCENDING);
List<Entity> greetings = datastore.prepare(query).asList(FetchOptions.Builder.withLimit(5));
if (greetings.isEmpty()) {
%>
<p>Guestbook '<%= guestbookName %>' has no messages.</p>
<%
} else {
%>
<p>Messages in Guestbook '<%= guestbookName %>'.</p>
<%
for (Entity greeting : greetings) {
if (greeting.getProperty("user") == null) {
%>
<p>An anonymous person wrote:</p>
<%
} else {
%>
<p><b><%= ((User) greeting.getProperty("user")).getNickname() %></b> wrote:</p>
<%
}
%>
<blockquote><%= greeting.getProperty("content") %></blockquote>
<%
}
}
%>

<form action="/sign" method="post">
<div><textarea name="content" rows="3" cols="60"></textarea></div>
<div><input type="submit" value="Post Greeting" /></div>
<input type="hidden" name="guestbookName" value="<%= guestbookName %>"/>
</form>

<form action="/guestbook.jsp" method="get">
<div><input type="text" name="guestbookName" value="<%= guestbookName %>"/></div>
<div><input type="submit" value="Switch Guestbook" /></div>
</form>

</body>
</html>

La pàgina comença fent la importació de les classes del Google App Engine que farà servir després.

<%@ page import="com.google.appengine.api.users.User" %>
<%@ page import="com.google.appengine.api.users.UserService" %>
<%@ page import="com.google.appengine.api.users.UserServiceFactory" %>
<%@ page import="com.google.appengine.api.datastore.DatastoreServiceFactory" %>
<%@ page import="com.google.appengine.api.datastore.DatastoreService" %>
<%@ page import="com.google.appengine.api.datastore.Query" %>
<%@ page import="com.google.appengine.api.datastore.Entity" %>
<%@ page import="com.google.appengine.api.datastore.FetchOptions" %>
<%@ page import="com.google.appengine.api.datastore.Key" %>
<%@ page import="com.google.appengine.api.datastore.KeyFactory" %>

A continuació, determina si l'usuari està logat amb userService.getCurrentUser(); per a poder presentar l'opció de logar-se (userService.createLoginURL(request.getRequestURI())) o deslogar-se (userService.createLogoutURL(request.getRequestURI())) .

Segueix amb la preparació de la "base de dades": el DataStore. Per defecte el llibre de visites és el "default". Es podran crear altres llibres de visites amb el paràmetre guestbookName. Aquest paràmetre es podrà modificar amb el formulari que presenta la pàgina.

Amb Key guestbookKey = KeyFactory.createKey("Guestbook", guestbookName); es crea el llibre de visites (o s'obre per accedir-hi si ja existia) i se n'obté la clau de referència (compte que els DataStore NO són bases de dades relacionals!).

A continuació obté la llista dels cinc darrers missatges del llibre de visites ordenats per data, des del més recent:

Query query = new Query("Greeting", guestbookKey).addSort("date", Query.SortDirection.DESCENDING);
List<Entity> greetings = datastore.prepare(query).asList(FetchOptions.Builder.withLimit(5))

Si no hi han missatges, n'informa:

if (greetings.isEmpty()) {
%>
<p>Guestbook '<%= guestbookName %>' has no messages.</p>
<%

I si n'hi han, itera per la llista presentant-ne l'autor i el text del missatge:

} else {
%>
<p>Messages in Guestbook '<%= guestbookName %>'.</p>
<%
for (Entity greeting : greetings) {
if (greeting.getProperty("user") == null) {
%>
<p>An anonymous person wrote:</p>
<%
} else {
%>
<p><b><%= ((User) greeting.getProperty("user")).getNickname() %></b> wrote:</p>
<%
}
%>
<blockquote><%= greeting.getProperty("content") %></blockquote>
<%
}
}

Finalment, la pàgina presenta els camps en el que es pot introduir el missatge i seleccionar el llibre de visites en el que es vol desar.
Internament, els dos camps s'organitzen en dos formularis HTML, el primer invoca al servlet /sign i li passa el text del missatge i el llibre de visites en el que ha d'inserir-lo. El segon formulari auto-invoca la mateixa pàgina guestbook.jsp i permet modificar el paràmetre guestbookName (per defecte, default), es dir, permet crear un llibre de vistes nou, o seleccionar-ne un d'existent.

<form action="/sign" method="post">
<div><textarea name="content" rows="3" cols="60"></textarea></div>
<div><input type="submit" value="Post Greeting" /></div>
<input type="hidden" name="guestbookName" value="<%= guestbookName %>"/>
</form>

<form action="/guestbook.jsp" method="get">
<div><input type="text" name="guestbookName" value="<%= guestbookName %>"/></div>
<div><input type="submit" value="Switch Guestbook" /></div>
</form>

La pàgina guestbook.jsp fa molta de l'operativa del llibre de visites tota sola, però cal alguna cosa més. a a la carpeta appengine-java-sdk/demos/guestbook/src també trobo el codi font del parell de servlets que completen l'aplicació (més un parell de classes auxiliars):

Els servlets són invocats pels formularis anteriors. A web.xml (a la carpeta appengine-java-sdk/demos/guestbook/war/WEB-INF/web.xml) veig que

<web-app xmlns="http://java.sun.com/xml/ns/javaee" version="2.5">

<servlet>

<servlet-name>guestbook</servlet-name>

<servlet-class>guestbook.GuestbookServlet</servlet-class>
</servlet>

<servlet-mapping>

<servlet-name>guestbook</servlet-name>

<url-pattern>/guestbook</url-pattern>
</servlet-mapping>

<servlet>

<servlet-name>sign</servlet-name>

<servlet-class>guestbook.SignGuestbookServlet</servlet-class>
</servlet>

<servlet-mapping>

<servlet-name>sign</servlet-name>

<url-pattern>/sign</url-pattern>
</servlet-mapping>

<welcome-file-list>

<welcome-file>guestbook.jsp</welcome-file>
</welcome-file-list>

</web-app>

Per tant /sign es refereix a SignGuestbookServlet.

package guestbook;

import java.io.IOException;
import java.util.Date;
import java.util.logging.Logger;
import javax.jdo.PersistenceManager;
import javax.servlet.http.*;
import com.google.appengine.api.users.User;
import com.google.appengine.api.users.UserService;
import com.google.appengine.api.users.UserServiceFactory;

import guestbook.Greeting;
import guestbook.PMF;

public class SignGuestbookServlet extends HttpServlet {
private static final Logger log = Logger.getLogger(SignGuestbookServlet.class.getName());

public void doPost(HttpServletRequest req, HttpServletResponse resp)
throws IOException {
UserService userService = UserServiceFactory.getUserService();
User user = userService.getCurrentUser();

String content = req.getParameter("content");
Date date = new Date();
Greeting greeting = new Greeting(user, content, date);

PersistenceManager pm = PMF.get().getPersistenceManager();
try {
pm.makePersistent(greeting);
} finally {
pm.close();
}

resp.sendRedirect("/guestbook.jsp");
}
}

Hi veig la importació de les classes de l'AppEngine que permeten fer l'autenticació (User, UserService i UserServiceFactory). També fa la importació de les classes auxiliars Greeting i PMF.

La persistència de dades s'aconsegueix amb JDO. Greeting correspon al model. i PMF és el PersistenceManagerFactory.

Greeting:

package guestbook;

import java.util.Date;
import javax.jdo.annotations.IdGeneratorStrategy;
import javax.jdo.annotations.IdentityType;
import javax.jdo.annotations.PersistenceCapable;
import javax.jdo.annotations.Persistent;
import javax.jdo.annotations.PrimaryKey;
import com.google.appengine.api.users.User;

@PersistenceCapable(identityType = IdentityType.APPLICATION)
public class Greeting {
@PrimaryKey
@Persistent(valueStrategy = IdGeneratorStrategy.IDENTITY)
private Long id;

@Persistent
private User author;

@Persistent
private String content;

@Persistent
private Date date;

public Greeting(User author, String content, Date date) {
this.author = author;
this.content = content;
this.date = date;
}

public Long getId() {
return id;
}

public User getAuthor() {
return author;
}

public String getContent() {
return content;
}

public Date getDate() {
return date;
}

public void setAuthor(User author) {
this.author = author;
}

public void setContent(String content) {
this.content = content;
}

public void setDate(Date date) {
this.date = date;
}
}

i PMF:

package guestbook;

import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManagerFactory;

public final class PMF {
private static final PersistenceManagerFactory pmfInstance =
JDOHelper.getPersistenceManagerFactory("transactions-optional");

private PMF() {}

public static PersistenceManagerFactory get() {
return pmfInstance;
}
}

A appengine-java-sdk/demos/guestbook/war/WEB-INF/classes/META-INF trobarem el fitxer de configuració de JDO: el jdoconfig.xml ,on es diu que es farà servir el appengine per a la persistència.

<persistence-manager-factory name="transactions-optional">

<property name="javax.jdo.PersistenceManagerFactoryClass"value="org.datanucleus.store.appengine.jdo.DatastoreJDOPersistenceManagerFactory"/>

<property name="javax.jdo.option.ConnectionURL" value="appengine"/>

</persistence-manager-factory>

</jdoconfig>

Amb JDO, gravar la informació és tan senzill com instanciar el model (Greeting greeting = new Greeting(user, content, date);) i fer-lo persistent (pm.makePersistent(greeting);)

L'altre servlet és GuestbookServlet

package guestbook;

import java.io.IOException;
import javax.servlet.http.*;
import com.google.appengine.api.users.User;
import com.google.appengine.api.users.UserService;
import com.google.appengine.api.users.UserServiceFactory;

public class GuestbookServlet extends HttpServlet {
public void doGet(HttpServletRequest req, HttpServletResponse resp)
throws IOException {
UserService userService = UserServiceFactory.getUserService();
User user = userService.getCurrentUser();

if (user != null) {
resp.setContentType("text/plain");
resp.getWriter().println("Hello, " + user.getNickname());
} else {
resp.sendRedirect(userService.createLoginURL(req.getRequestURI()));
}
}
}

Aquest segon servlet no s'invoca directament en el codi. Es tracta d'un servlet que ens mostra com utilitzar la Users API per a, depenent de si l'usuari està logat o no, fer una acció o altre. Per a invocar-lo directament faig

http://localhost:8080/guestbook.

Suposant que no m'he logat abans (fent click a sign in), El resultat és que es mostra el següent:

En l'entorn amb el que faig les proves, la invocació a createLoginURL porta a una pantalla com l'anterior. El que fa el servlet és que si l'usuari no estàlogat, redirecciona a aquesta pantalla de login. Si estiguéssim a l'entorn "de producció" de Google, aleshores ens dirigiríem a la pàgina de login de Google.

Tornant a l'entorn de prova, si en canvi hagués estat logat obtindria:

Una aplicació ben senzilla. Tampoc hi ha gaire cosa a explicar del codi.

Un cop ja tinc l'aplicació en funcionament, ve el moment de desplegar-la en producció. He de fer "el deploy".

El desplegament és també molt senzill. Primer de tot cal identificar-se al Google App Engine. Accedeixo a la web http://code.google.com/intl/ca-ES/appengine/ i faig click a Sign Up.

I creo una aplicació. Click a Create Application.

Em demana un número de telèfon per verificar la creació

Des de Barcelona, el codi de regió és +34. Rebo el codi i l'he de posar a la següent pantalla.

Ara he d'emplenar un formulari de registre de l'aplicació. Poso el títol de l'aplicació, i l'identificador. Fixem-nos que aquí es defineix la URL d'accés de l'aplicació. En aquest cas serà

http://stsoftlliure-proves.appspot.com

Accepto les condicions del servei i, finalment, l'aplicació queda registrada.

Ara que ja tinc preparat l'espai on ubicar l'aplicació, faig el deploy des de la línia de comandes, dent servir l'aplicació appcfg.h que es proporciona amb l'SDK de l'App Engine. L'aplicació ens demanarà el correu gmail del compte i el password. Es connectarà a Internet i desplegarà l'aplicació. Fixem-nos que no cal crear un fitxer .war.

albert@apolo:~/appengine-java-sdk/bin$ appcfg.sh -A stsoftlliure-proves update /home/albert/appengine-java-sdk/demos/guestbook/war
Reading application configuration data...
19/02/2012 13:16:45 com.google.apphosting.utils.config.AppEngineWebXmlReader readAppEngineWebXml
INFO: Successfully processed /home/albert/appengine-java-sdk/demos/guestbook/war/WEB-INF/appengine-web.xml
2012-02-19 13:16:45.947:INFO::Logging to STDERR via org.mortbay.log.StdErrLog
19/02/2012 13:16:46 com.google.apphosting.utils.config.AbstractConfigXmlReader readConfigXml
INFO: Successfully processed /home/albert/appengine-java-sdk/demos/guestbook/war/WEB-INF/web.xml
19/02/2012 13:16:46 com.google.apphosting.utils.config.IndexesXmlReader readConfigXml
INFO: Successfully processed /home/albert/appengine-java-sdk/demos/guestbook/war/WEB-INF/appengine-generated/datastore-indexes-auto.xml
Beginning server interaction for stsoftlliure-proves...
0% Created staging directory at: '/tmp/appcfg2668004339756750410.tmp'
5% Scanning for jsp files.
8% Compiling jsp files.
19/02/2012 13:16:55 com.google.apphosting.utils.config.AbstractConfigXmlReader readConfigXml
INFO: Successfully processed /tmp/appcfg2668004339756750410.tmp/WEB-INF/web.xml
20% Scanning files on local disk.
25% Initiating update.
28% Cloning 1 static files.
31% Cloning 27 application files.
40% Uploading 1 files.
52% Uploaded 1 files.
61% Initializing precompilation...
68% Sending batch containing 1 file(s) totaling 1KB.
90% Deploying new version.
95% Will check again in 1 seconds.
98% Will check again in 2 seconds.
99% Will check again in 4 seconds.
99% Closing update: new version is ready to start serving.
99% Uploading index definitions.

Update completed successfully.
Success.
Cleaning up temporary files...
albert@apolo:~/appengine-java-sdk/bin$

Verifico que la nova aplicació ja és visible al Dashboard...

...I ja puc fer servir la meva nova aplicació instal·lada al Google App Engine.

Accedeixo a l'adreça http://stsoftlliure-proves.appspot.com i puc provar l'aplicació:

Lubuntu a un Hercules eCafe 800

2011-12-11T22:18:00.001+01:00

En un post anterior vam instal·lar Ubuntu de la darrera versió Netbook Remix en un petit Hercules eCafe 800.La maquineta ha funcionat prou bé però ha estat evident, des del primer dia, que Gnome li anava gran.

La solució ha estat posar una distribució més lleugera. En aquest cas la Lubuntu. Lubuntu és una distribució que fa servir LXDE com a entorn d'escriptori i OpenBox com a gestor de finestres, amb la intenció de minimitzar el consum de recursos que calen. Vegeu també http://ca.wikipedia.org/wiki/Lubuntu. Per cert, està disponible en català.

La instal·lació no ha tingut complicacions: he descarregat la iso de http://cdimages.ubuntu.com/lubuntu/releases/11.10/release/ i he creat un pendrive d'instal·lació.

Per a fer la instal·lació m'ha estat útil connectar un monitor extern, degut a que la petita pantalla de l'eCafe no era suficient per als continguts que s'estaven mostrant. Aquest problema ja el vaig trobar en l'anterior instal·lació de Ubuntu (Gnome), i es resol igual: un cop feta la instal·lació cal afegir el fitxer xorg.conf a /etc/X11.

Un cop feta la instal·lació i fet l'ajust de pantalla, ja es pot treballar amb el netbook. Ens adonarem d'alguns canvis, per exemple en el programari instal·lat. Per mi el més cridaner ha estat trobar Chromium, el navegador open-source que ha servit de base per a Chrome, en comptes de Firefox. I també trobar Synaptic, en comptes del "Centre de Programari de l'Ubuntu".

La millora en la reproducció de vídeos i música és evident. També en la reproducció de vídeos online.

Pegues, de moment, poques. Li he instal·lat Thunderbird, LibreOffice, Skype... i el netbook els mou de forma que són útils. No està gens malament per a aquesta petita maquina.

Potser encara posaré Lubuntu a l'ordinador de sobretaula.

Codis QR amb Java i ZXing

2011-12-06T23:05:00.001+01:00

Cada cop és més comú trobar arreu codis QR. Els codis QR apareixen en promocions i en publicitat de tots tipus. Sens dubte que les aplicacions per a telèfons mòbils que permeten descodificar aquests codis de barres han contribuït a popularitzar los i, a la vegada, són un estímul més per a fer-se amb un smartphone que permeti gaudir-ne d'aquesta capacitat. Es tracta de dues tecnologies que es reforcen l'una a l'altre.

Vet aquí el que en diu la Viquipèdia dels codis QR:

"El codi QR (en anglès QR Code) és un codi de barres en 2 dimensions (codi matriu) que pot emmagatzemar fins a 7089 caràcters numèrics, 4296 caràcters alfanumèrics (contràriament al codi de barres "tradicional" que només pot emmagatzemar de 10 a 13 caràcters) o 2953 octets .

Per accedir a la informació continguda o encriptada en un qr-code, és necessari un dispositiu digital de captura d'imatges ( Ex: càmera de fotos d'un mòbil, webcam...) i un software específic lector de qr-codes.

Té l'avantatge de poder emmagatzemar moltes informacions tot i ser petit i ràpid d'escanejar. Així, les sigles «QR» deriven de «Quick Response» ja que el contingut pot ser desxifrat ràpidament.

La informació oculta en el codi pot estar en forma de:

TEXT

URL (ens permetrà visitar una pàgina web concreta amb un sol clic)

SMS ( podrem enviar un sms predeterminat a un número de predeterminat amb un sol clic)

VCARD (targes de presentació)

Les possibilitats i aplicacions d'aquests codis en gestió i màrqueting (especialment en opt-in màrqueting i promocions) són novedoses i interessants ja que mitjançant els codis qr es poden unir dos suports històricament aïllats: paper i internet o tinta i bits.

El codi QR ha estat creat per l'empresa japonesa Denso-Wave el 1994. El codi QR és molt emprat al Japó, on actualment és el codi de dues dimensions més popular.

L'estàndard japonès per als codis QR, JIS X 0510, ha estat publicat el 1999, i la norma ISO corresponent, ISO/IEC 18004, ha estat aprovada el juny de 2000.

Un detall important sobre el codi QR, seria que es tracta de codi obert i els seus drets de patent (propietat de Denso Wave) no són exercits."

Que els codis QR siguin d'alguna manera codi open source tampoc deu ser aliè al seu èxit.

Però, i com es poden crear codis QQ? i com descodificar-los? Més concretament, com crear o llegir codis QR amb Java ( o amb JVM)? Una cerca ràpida amb Google ens mostra diverses llibreries. Em crida l'atenció la llibreria ZXing.

ZXing és una llibreria per al processat d'imatges de codis de barres de 1D/2D per a clients Android i Java.

Dit i fet, descarrego la llibreria (versió 1.7) d'aquí: http://code.google.com/p/zxing/downloads/detail?name=ZXing-1.7.zip, i la descomprimeixo.

El paquet té la següent estructura:

albert@athena:~/zxing$ ls
actionscript androidtest build.properties COPYING csharp javase README zxing.appspot.com
android AUTHORS build.xml core iphone jruby rim zxingorg
android-integration bug CHANGES cpp javame objc symbian
albert@athena:~/zxing$

Observem que no hi han jars. Cal compilar-los. És tan senzill com, en un terminal, moure's primrer a la carpeta core i executar ant, i després a la carpeta javase i tornar a excutar ant. Cal, evidentment, tenir ant instal·lat.

De moment, seguiré les instruccions que posen al lloc web de ZXing.

albert@athena:~/zxing$ cd core

albert@athena:~/zxing/core$ ls

build build.xml lib pom.xml src test

albert@athena:~/zxing/core$ ant

Buildfile: /home/albert/zxing/core/build.xml

clean:

[delete] Deleting directory /home/albert/zxing/core/build

build:

init:

compile:

[mkdir] Created dir: /home/albert/zxing/core/build

[javac] Compiling 177 source files to /home/albert/zxing/core/build

[javac] warning: [options] bootstrap class path not set in conjunction with -source 1.3

[javac] 1 warning

[jar] Building jar: /home/albert/zxing/core/core.jar

BUILD SUCCESSFUL

Total time: 34 seconds

albert@athena:~/zxing/core$ cd ../javase

albert@athena:~/zxing/javase$ ls

build build.xml pom.xml src

albert@athena:~/zxing/javase$ ant

Buildfile: /home/albert/zxing/javase/build.xml

init:

build:

[jar] Building jar: /home/albert/zxing/javase/javase.jar

BUILD SUCCESSFUL

Total time: 6 seconds

albert@athena:~/zxing/javase$

Si examinem de nou les carpetes core i javase trobarem core.jar i javase.jar a les carpetes de mateix nom:

albert@athena:~/zxing/javase$ ls

build build.xml javase.jar pom.xml src

albert@athena:~/zxing/javase$ cd ../core

albert@athena:~/zxing/core$ ls

build build.xml core.jar lib pom.xml src test

albert@athena:~/zxing/core$

En aquest moment es pot fer una prova. Faré servir la següent imatge:

I ara, fem la prova executant la classe CommandLineRunner que permet descodificar una imatge:

albert@athena:~/zxing$ java -cp javase/javase.jar:core/core.jar com.google.zxing.client.j2se.CommandLineRunner ./sticipl.png

file:/home/albert/zxing/./sticipl.png (format: QR_CODE, type: TEXT):

Raw result:

Serveis TIC i Programari Lliure

Parsed result:

Serveis TIC i Programari Lliure

Found 4 result points.

Point 0: (14.0,102.0)

Point 1: (14.0,14.0)

Point 2: (102.0,14.0)

Point 3: (90.0,90.0)

albert@athena:~/zxing$

Pel que fa a la documentació, el javadoc de ZXing el podem trobar a http://zxing.org/w/docs/javadoc/index.html

També ens pot ajudar la pàgina de les DeveloperNotes (http://code.google.com/p/zxing/wiki/DeveloperNotes)

El que faré serà un parell de programes d'exemple, un per a crear codis de barra QR i un altre per a descodificar-los. Un coder i un decoder d'exemple.

Primer de tot, el decoder. L'aplicaré al següent QR:

Vet aquí el codi:

package com.sticipl.prova.zxing;

import com.google.zxing.Reader;
import com.google.zxing.qrcode.QRCodeReader;
import com.google.zxing.client.j2se.BufferedImageLuminanceSource;
import com.google.zxing.LuminanceSource;
import com.google.zxing.common.HybridBinarizer;
import com.google.zxing.BinaryBitmap;
import com.google.zxing.BarcodeFormat;
import com.google.zxing.ResultPoint;
import com.google.zxing.Result;
import java.awt.image.BufferedImage;
import java.io.File;
import javax.imageio.ImageIO;

public class ProvaZxing {
public ProvaZxing() {
try {
Reader reader = new QRCodeReader();

BufferedImage myImage = ImageIO.read(
new File("/home/albert/Workspace/wk-java/prova-zxing/img/albert.png")
);
LuminanceSource source = new BufferedImageLuminanceSource(myImage);
BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(source));

Result result = reader.decode(bitmap);

String text = result.getText();
System.out.println("Text llegit: " + text);

byte[] rawBytes = result.getRawBytes();
for (byte byteElem : rawBytes) {
System.out.println("Byte: " + byteElem);
}

BarcodeFormat format = result.getBarcodeFormat();
System.out.println("Format del codi: " + format);

ResultPoint[] punts = result.getResultPoints();
for (ResultPoint punt : punts) {
System.out.println("Punt.x: " + punt.getX() + "; Punt.y: " + punt.getY());
}
} catch(Exception e) {
System.out.println("Error: " + e.toString());
}
}

public static void main(String args[]) {
new ProvaZxing();
  }
}

El programa és directe: instancia un reader del tipus QRCodeReader, crea una BufferedImage a partir de la imatge del QR. El reader s'aplica al QRReder i, senzillament, el descodifica. El resultat s'obté en diferents formats.

L'aplicació del programa sobre la darrera imatge proporciona la sortida:

Text llegit: Albert Baranguer Codina
Byte: 65
Byte: 116
Byte: 22
Byte: -58
Byte: 38
Byte: 87
Byte: 39
Byte: 66
Byte: 4
Byte: 38
Byte: 23
Byte: 38
Byte: 22
Byte: -26
Byte: 119
Byte: 86
Byte: 87
Byte: 34
Byte: 4
Byte: 54
Byte: -10
Byte: 70
Byte: -106
Byte: -26
Byte: 16
Byte: -20
Byte: 17
Byte: -20
Format del codi: QR_CODE
Punt.x: 14.0; Punt.y: 86.0
Punt.x: 14.0; Punt.y: 14.0
Punt.x: 86.0; Punt.y: 14.0
Punt.x: 74.0; Punt.y: 74.0

La creació de codis QR no té dificultat i segueix un procediment similar al de la descodificació: primer de tot, cal instanciar un QRCodeWriter i amb aquesta instància, directament es codifica la informació. El resultat és una matriu de bits que es fa servir per a crear una BufferedImage. Vet aquí el mètode codifica(String sText), que rep com a argument el text a codificar

// genera un codi QR per al text passat
public void codifica(String sCadena) {
try {
Writer writer = new QRCodeWriter();
BitMatrix bitmat = writer.encode(sCadena, BarcodeFormat.QR_CODE, 200, 200);

// genera la imatge.
// Obté ample i alt
int width = bitmat.getWidth();
int height = bitmat.getHeight();

// crea BufferedImage
BufferedImage imatge = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

// estableix els bits de la imatge (true, negre; false, blanc)
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
boolean boolPunt = bitmat.get(x,y);
imatge.setRGB(x, y, (boolPunt ? 0 : 0xFFFFFF));
}
}

// genera el fitxer d'imatge a partir de la BufferedImage
File file = new File("/home/albert/Workspace/wk-java/prova-zxing/img/generat.png");
FileOutputStream fos = new FileOutputStream(file);
ImageIO.write(imatge, "png", fos);
fos.flush();
fos.close();
} catch(Exception e) {
System.out.println("Error: " + e.toString());
}
}

Aplicant el mètode amb els argument mostrats:

public static void main(String args[]) {
ProvaZxing prova = new ProvaZxing();
// prova.decode();
prova.codifica("Generat amb Zxing - Serveis TIC i Programari Lliure - Albert Baranguer Codina - accents: àèò éíóú ç ñ ...");
}

obtinc la imatge:

Per acabar, una altre imatge generada amb el mètode codifica(). Endevineu quin és el text que amaga?

Groovy i HSQLDB

2011-11-20T22:21:00.001+01:00

Groovy aporta classes per al treball amb bases de dades que permeten un increment de la productivitat en el desenvolupament de codi d'aplicacions que en facin us.

Dit d'una altre forma: Groovy permet simplificar el codi de les aplicacions de bases de dades. Res millor que un exemple.

En l'exercici que es proposa faré us de la base de dades HSQLDB, que és el motor de base de dades que es fa servir, per exemple, a les suites ofimàtiques OpenOffice.org i LibreOffice.

Per a poder utilitzar HSQLDB des de Groovy cal afegir el hsqldb.jar a les llibreries que es carreguen a l'inici. En el cas que m'ocupa, un Groovy sobre Linux Ubuntu, cal revisar el fitxer $GROOVY_HOME/conf/groovy-starter.conf en el que es pot trobar el següent:

# load user specific libraries
load !{user.home}/.groovy/lib/*.jar

Tinc l'HSQLDB instal·lat a una carpeta apart. Per tant, per evitar duplicitats, en comptes de posar l'hsqldb.jar a $HOME/.groovy/lib, el que faig és posar en aquesta carpeta un enllaç simbòlic al jar que hi ha a la carpeta on està desplegat el motor de la base de dades.

A continuació, creo una base de dades del tipus fitxer i standalone. Cal dir que HSQLDB pot funcionar en "mode servidor" o bé en "mode standalone". A més, també pot funcionar o bé mantenint les dades en un fitxer, o bé "mantenint" les dades en memòria (evidentment, només es "mantenen" mentre el procés és viu).

Per a crear la taula es pot fer servir, per exemple, l'OpenOffice.org/LibreOffice Base. En aquest cas caldria afegir hsqldb.jar al classpath de l'OOo/LO (eines - opcions - java)

i camí a les classes:

i, a continuació, crearia una base de dades del tipus Jdbc.

En el meu cas, la base de dades la fico a Documentes/databases/hsqldb/prova.db, per tant la URL JDBC que he de fer servir és:

jdbc:hsqldb:/home/albert/Documents/databases/hsqldb/prova.db

i el driver:

org.hsqldb.jdbc.JDBCDriver

(canviar aquesta imatge)

Això em permetrà fer servir l'assistent de l'OOo/LO per a definir la taula i els tipus de dades. Creo una taula diccionari amb tres columnes: id (enter), nom (varchar de 100) i valor (varchar de 100).

I un cop creada la taula, la informo amb algunes dades de prova:

Probablement la classe més útil de Groovy per al treball amb bases de dades sigui groovy.sql.Sql. Aquesta classe és una mena de navalla suïssa que proporciona una varietat de mètodes per a fer gairebé totes les tasques comuns amb taules.

La pàgina de la documentació de groovy.sql.Sql ens explica les possibilitats d'aquesta navalla suïssa.

Per a utilitzar-la cal importar-la

import groovy.sql.Sql

A continuació puc configurar la connexió a la base de dades que he creat fa un moment:

def ds = [url:'jdbc:hsqldb:/home/albert/Documents/databases/hsqldb/prova.db',

user:'sa',

password:'',

driver:'org.hsqldb.jdbc.JDBCDriver']

def sql = Sql.newInstance(ds.url, ds.user, ds.password, ds.driver)

Consulto la taula que he creat amb el OOo/LO amb el potent mètode eachRow, adonem-nos com la fila en curs és accessible amb 'it':

sql.eachRow("select * from public.\"diccionari\" where \"id\" >= 3") {
println "id = ${it.id}; nom = ${it.nom}; valor = ${it.valor}"
}

i el resultat és

albert@athena:~/Workspace/wk-groovy/prova-jdbc$ groovy provabd.groovy
id = 3; nom = nom3; valor = valor3
id = 4; nom = nom4; valor = valor3
id = 5; nom = nom5; valor = valor5

Creo una nova taula i la informo amb dades. Cal tenir en compte algunes particularitats de l'SQL de l'HSQLDB: els noms de les taules han d'anar precedides de l'esquema; els noms de taules, columnes i d'altres objectes van entre cometes dobles; els literals van entre comentes simples.

sql.execute '''
create table public.\"traductor\" (
\"id\" integer not null,
\"catala\" varchar(100),
\"castella\" varchar(100),
)
'''

Faig insert de dades amb diferents mètodes:

- fent servir la sintaxi amb '''
sql.execute '''
insert into public.\"traductor\"(\"id\",\"catala\",\"castella\") values (1, 'catala 1','castella 1')
'''
println "inserta fila 1"

- fent servir la sintaxi de preparedStatement de JDBC
def params = [2, 'catala 2', 'castella 2']
sql.execute("insert into public.\"traductor\" (\"id\", \"catala\", \"castella\") values (?, ?, ?)", params)
println "inserta fila 2"

params = [3, 'catala 3', 'castella 3']
sql.execute("insert into public.\"traductor\" (\"id\", \"catala\", \"castella\") values (?, ?, ?)", params)
println "inserta fila 3"

- fent servir la sintaxi GString
def map = [id:4, catala:'català 4', castella:'castellà 4']
sql.execute("insert into public.\"traductor\" (\"id\", \"catala\", \"castella\") values ($map.id, $map.catala, $map.castella)")
println "inserta fila 4"

Visualitzo els resultats amb eachRow, ara fent servir el paràmetre fila a la closure, en comptes d'it.

sql.eachRow("select * from public.\"traductor\"") {fila ->
println "id = $fila.id; català = $fila.catala; castellà = $fila.castella"
}

Després d'aquestes accions, tinc les dues taules amb dades, com puc veure amb l'OOo/LO

He fet inserts, evidentment també es poden fer update, delete... fent servir execute, o millor executeUpdate, que em retorna una llista de les files afectades.

eachRow admet paginació. He afegit algunes dades més a la taula traductor i la visualitzo, primer tota i després mostrant només quatre files a partir de la fila tres:

println "mostra la taula \"traductor\""
sql.eachRow("select * from public.\"traductor\"") {fila ->
println "id = $fila.id; català = $fila.catala; castellà = $fila.castella"
}

println "mostra 4 files de la taula \"traductor\" a partir de la fila 3"
sql.eachRow("select * from public.\"traductor\"", 3, 4 ) {fila ->
println "id = $fila.id; català = $fila.catala; castellà = $fila.castella"
}

El resultat és:
mostra la taula "traductor"

id = 1; català = catala 1; castellà = castella 1
id = 2; català = catala 2; castellà = castella 2
id = 3; català = catala 3; castellà = castella 3
id = 4; català = català 4; castellà = castellà 4
id = 5; català = catala 5; castellà = castella 5
id = 6; català = catala 6; castellà = castella 6
id = 7; català = catala 7; castellà = castella 7
id = 8; català = català 8; castellà = castellà 8
mostra 4 files de la taula "traductor" a partir de la fila 3
id = 3; català = catala 3; castellà = castella 3
id = 4; català = català 4; castellà = castellà 4
id = 5; català = catala 5; castellà = castella 5
id = 6; català = catala 6; castellà = castella 6

La classe groovy.sql.Sql té altres mètodes que també permeten augmentar la productivitat del desenvolupament, que s'afegeixen al fet que els scripts en Groovy no requereixen compilació.

groovy.sql.Sql també té mètodes que retornen ResultSet de jdbc, permetent el tractament típic de Java.

El package groovy.sql també inclou la classe DataSet que deriva de groovy.sql.Sql i que permet fer queries a la base de dades fent servir operadors i noms de camps de Groovy en comptes de crides a API JDBC i noms de taules i columnes. Un petit exemple:

Primer de tot, cal importar DataSet

import groovy.sql.DataSet

i ja el puc fer servir:

primer mostro el contingut de la taula amb eachRow d'Sql i després fa la query amb DataSet

println "mostra la taula \"traductor\""

sql.eachRow("select * from public.\"traductor\"") {fila ->

println "id = $fila.id; català = $fila.catala; castellà = $fila.castella"

}

println "mostra valors amb id entre 3 i 7 fent servir la classe DataSet"

def traduccions = sql.dataSet("public.\"traductor\"")

def filtrat = traduccions.findAll {it."\"id\"" >= 3 && it."\"id\"" <= 7 }

filtrat.each { fila ->

println "id = $fila.id; català = $fila.catala; castellà = $fila.castella"

}

El resultat és el següent

mostra la taula "traductor"

id = 1; català = catala 1; castellà = castella 1

id = 2; català = catala 2; castellà = castella 2

id = 3; català = catala 3; castellà = castella 3

id = 4; català = català 4; castellà = castellà 4

id = 5; català = catala 5; castellà = castella 5

id = 6; català = catala 6; castellà = castella 6

id = 7; català = catala 7; castellà = castella 7

id = 8; català = català 8; castellà = castellà 8

mostra valors amb id entre 3 i 7 fent servir la classe DataSet

id = 3; català = catala 3; castellà = castella 3

id = 4; català = català 4; castellà = castellà 4

id = 5; català = catala 5; castellà = castella 5

id = 6; català = catala 6; castellà = castella 6

id = 7; català = catala 7; castellà = castella 7

En aquest exemple les particularitats de HSQLDB pel que fa als noms de taules i columnes entre cometes no permeten aprofitar la simplificació de fer servir els noms de les columnes com si fossin noms de camps Groovy de l'objecte it. Però, si més no, es permet veure l'ús de l'operador && per a construir el "where" del Dataset

I finalment, per acabar...

// tanca la connexió

sql.close()

Un "Piulador" amb Twitter4J amb gestió de l'autenticació

2011-11-01T23:04:00.004+01:00

En el post anterior vaig fer un "piulador" personal que em permet enviar tweets (o piulades) al compte associat a l'Access Token.

Per obtenir l'Access Token i l'Access Token Secret va caldre demanar-los a la web de Twitter. Els valors que em va proporcionar Twitter els vaig fer servir posant-los a l'objecte de la classe ConfigurationBuilder que passava com argument al constructor de l'objecte de la classe Twitter que és el que permet l'operació.

Un cop obtinguts l'Access Token i l'Access Token Secretm aquests dos valors els podrà fer servir el Piulador indefinidament. L'usuari pot, però, forçar que se'n generin de nous des de la web de Twitter.

Per a que el "Piulador" el pugui fer servir tothom que tingui un compte a Twitter cal que sigui el mateix piulador qui el demani i en gestioni l'obtenció. Això és el que faré avui.

El codi del partida és el Piulador del post anterior:

package com.sticipl.proves;

import twitter4j.Status;
import twitter4j.Twitter;
import twitter4j.TwitterException;
import twitter4j.TwitterFactory;
import twitter4j.conf.ConfigurationBuilder;

public final class ProvaTwitter {
/**
* Usage: java twitter4j.examples.tweets.UpdateStatus [text]
*
* @param args message
*/
public static void main(String[] args) {
try {
   ConfigurationBuilder cb = new ConfigurationBuilder();
   cb.setDebugEnabled(true)
      .setOAuthConsumerKey("[El consumer Key obtingut]")
      .setOAuthConsumerSecret("[el consumer secret obtingut]")
      .setOAuthAccessToken("[l'access token obtingut]")
      .setOAuthAccessTokenSecret("[l'access token secret obtingut]");
   TwitterFactory tf = new TwitterFactory(cb.build());
   Twitter twitter = tf.getInstance();

Status status = twitter.updateStatus("Aquest és el missatge enviat des de l'aplicació #Java de prova fent us de #Twitter4J");
System.out.println("Actualitzat status a [" + status.getText() + "].");
System.exit(0);
} catch (TwitterException te) {
te.printStackTrace();
System.out.println("Excepció de Twitter: " + te.getMessage());
System.exit(-1);
}
}
}

El que cal fer és canviar el bloc de codi del ConfigurationBuilder per un bloc de codi que en gestioni l'obtenció del parell Access Token / Access Token Secret.

Al post anterior vaig dir que el Consumer ha de demanar l'autorització de l'usuari amb un Request Token i que aquest Request Token es bescanvia per l'Access Token. Com es fa això? A la secció dels exemples de codi de la web Twitter4J expliquen com:

http://twitter.com/oauth_clients/new

Twitter#setOAuthConsumer()

-Dtwitter4j.oauth.consumerKey=[consumer key]
-Dtwitter4j.oauth.consumerSecret=[consumer secret]

  public static void main(String args[]) thrwos Exception{
    // The factory instance is re-useable and thread safe.
    Twitter twitter = new TwitterFactory().getInstance();
    twitter.setOAuthConsumer("[consumer key]", "[consumer secret]");
    RequestToken requestToken = twitter.getOAuthRequestToken();
    AccessToken accessToken = null;
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    while (null == accessToken) {
      System.out.println("Open the following URL and grant access to your account:");
      System.out.println(requestToken.getAuthorizationURL());
      System.out.print("Enter the PIN(if aviailable) or just hit enter.[PIN]:");
      String pin = br.readLine();
      try{
         if(pin.length() > 0){
           accessToken = twitter.getOAuthAccessToken(requestToken, pin);
         }else{
           accessToken = twitter.getOAuthAccessToken();
         }
      } catch (TwitterException te) {
        if(401 == te.getStatusCode()){
          System.out.println("Unable to get the access token.");
        }else{
          te.printStackTrace();
        }
      }
    }
    //persist to the accessToken for future reference.
    storeAccessToken(twitter.verifyCredentials().getId() , accessToken);
    Status status = twitter.updateStatus(args[0]);
    System.out.println("Successfully updated the status to [" + status.getText() + "].");
    System.exit(0);
  }
  private static void storeAccessToken(int useId, AccessToken accessToken){
    //store accessToken.getToken()
    //store accessToken.getTokenSecret()
  }

El que faig és adaptar aquest codi al meu piulador:

package com.sticipl.proves;

import java.io.BufferedReader;

import java.io.FileWriter;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import twitter4j.Status;

import twitter4j.Twitter;

import twitter4j.TwitterException;

import twitter4j.TwitterFactory;

import twitter4j.auth.AccessToken;

import twitter4j.auth.RequestToken;

public final class ProvaTwitter {

private Twitter twitter;

private BufferedReader br;

/**

* Usage: java twitter4j.examples.tweets.UpdateStatus [text]

* @param args message

public static void main(String[] args) {

new ProvaTwitter();

}

public ProvaTwitter() {

try {

twitter = new TwitterFactory().getInstance();

AutenticaConsumer();

Status status = twitter.updateStatus("Aquest és el missatge enviat des de l'aplicació #Java de prova fent us de #Twitter4J. Versió 2");

System.out.println("Actualitzat status a [" + status.getText() + "].");

System.exit(0);

} catch (TwitterException te) {

te.printStackTrace();

System.out.println("Excepció de Twitter: " + te.getMessage());

System.exit(-1);

} catch (Exception e) {

e.printStackTrace();

System.out.println("Excepció general: " + e.getMessage());

System.exit(-2);

}

private void AutenticaConsumer() throws Exception{

twitter.setOAuthConsumer("[consumer key]", "[consumer key secret]");

RequestToken requestToken = twitter.getOAuthRequestToken();

AccessToken accessToken = null;

br = new BufferedReader(new InputStreamReader(System.in));

while (null == accessToken) {

System.out.print("Entra el nom d'aquest perfil d'accés a Twitter:");

String sNomPerfil = br.readLine();

System.out.println("Obre la següent URL a un navegador, identifica't amb el teu compte de twitter i autoritza al piulador:");

System.out.println(requestToken.getAuthorizationURL());

System.out.print("Entra el PIN(si està disponible) i prem enter:");

String pin = br.readLine();

try {

if(pin.length() > 0) {

accessToken = twitter.getOAuthAccessToken(requestToken, pin);

} else {

accessToken = twitter.getOAuthAccessToken();

}

//persist to the accessToken for future reference.

storeAccessToken(sNomPerfil, twitter.verifyCredentials().getId() , accessToken);

} catch (TwitterException te) {

if (401 == te.getStatusCode()) {

System.out.println("No ha pogut obtenir l'Access Token.");

} else {

te.printStackTrace();

}

private void storeAccessToken(String sNomPerfil, long l, AccessToken accessToken){

// guarda un fitxer amb:

// nom del perfil a guardar

// twitter.verifyCredentials().getId()

// guarda accessToken.getToken()

// guarda accessToken.getTokenSecret()

FileWriter fitxer = null;

PrintWriter pw = null;

try {

fitxer = new FileWriter("./twitter-access-token.txt");

pw = new PrintWriter(fitxer);

pw.println("Nom perfil: " + sNomPerfil );

pw.println("twitter.verifyCredentials().getId(): " + l );

pw.println("Access Token: " + accessToken.getToken() );

pw.println("Access Token Secret: " + accessToken.getTokenSecret() );

} catch (Exception e) {

e.printStackTrace();

} finally {

try {

if (null != fitxer)

fitxer.close();

} catch (Exception e2) {

e2.printStackTrace();

}

I l'executo:

Des del main s'invoca al constructor , el qual, primer de tot, va al mètode AutenticaConsumer, que és el que fa la negociació OAuth.

A AutenticaConsumer, s'estableixen el Consumer Key i el Cosumer Key Secret i, a continuació s'obté un Request Token.

Entra el nom d'aquest perfil d'accés a Twitter:sticipl

A continuació demana un nom de perfil d'accés al twitter per a identificar-lo en futures connexions. La idea és que guarda a un fitxer el nom del perfil i l'Access Token i l'Access Token Secret, de forma que per a futures connexions amb aquest perfil, podria fer servir directament aquests valors emmagatzemats localment, en comptes d'haver de tornar a demanar accés. En aquesta versió genera el fitxer, però no està implementada la recuperació per perfil de l'Acces Token. No costaria gaire fer-ho, però potser millor amb una bd HSQLDB que amb un fitxer pla.

Amb el Request Token obté la URL d'autorització. L'usuari ha d'anar a aquesta URL, identificar-se amb el compte de Twitter amb el que vol fer servir el piulador, i autoritzar al Piulador a poder enviar missatges.

Obre la següent URL a un navegador, identifica't amb el teu compte de twitter i autoritza al piulador:

http://api.twitter.com/oauth/authorize?oauth_token=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Dit i fet, copio la URL i l'enganxo a un navegador. Vaig a la web d'Autorització de Twitter. Com que ja estava logat a Twitter amb el compte de sticipl, aquesta és el compte per al que s'autoritzarà el Piulador. Però podria haver sortit i haver-me logat de nou amb un compte diferent :

Faig click a Authorize App i...

La pàgina de Twitter em proporciona un PIN. El piulador estava esperant a que li indiqués aquest PIN:

Entra el PIN(si està disponible) i prem enter:6865240

Un cop autoritzat, el mètode AutenticaConsumer invoca al mètode storeAccessToken que genera el fitxer amb l'Access Token i l'Access Token Key per a usos futurs. El fitxer generat és una cosa com aquesta:

Nom perfil: sticipl

twitter.verifyCredentials().getId(): 177894606

Access Token: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Access Token Secret: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

AutenticaConsumer acaba i torna al constructor, i el constructor fa la següent piulada:

Actualitzat status a [Aquest és el missatge enviat des de l'aplicació #Java de prova fent us de #Twitter4J. Versió 2].

Vet aquí el resultat:

Vet aquí, doncs, una versió del piulador amb autenticació OAuth gestionada des de la mateixa aplicació.

La web de Twitter4J ens ens proporciona codi d'exemple per a desenvolupar altres funcions del Twitter que aniré explorant en propers posts.

Un "Piulador" personal amb Twitter4J

2011-10-30T23:22:00.000+01:00

En el post d'avui crearé un petit "Piulador": una petita aplicació que em permetrà piular al Twitter.

El primer pas es descarregar l'API per al llenguatge de desenvolupament triat del lloc dels desenvolupadors de Twitter: https://dev.twitter.com/docs/twitter-libraries

Tenim APIs per a diferents llenguatges i amb diferents orígens. En particular per a Java, PHP, Python i C++ a la mateixa web dels desenvolupadors en destaquen aquestes:

C++: Twitcurl, http://code.google.com/p/twitcurl/.
Java: Twitter4J, http://twitter4j.org/.
PHP: TmhOAuth, http://github.com/themattharris/tmhOAuth.
Python: Tweepy, https://github.com/tweepy/tweepy

En el meu cas, desenvoluparé l'aplicació amb Java, així que el primer que faig és descarregar Twitter4j

A la web de Twitter4J en podem llegir algunes de les característiques d'aquesta API

"Twitter4J és una biblioteca java (jar) no oficial per a l'API de Twitter.
Amb Twitter4J, es pot integrar fàcilment una aplicació Java amb el servei de Twitter.

Twitter4J ofereix:
✔ és Java pur 100%. Funciona a partir de la versió de plataforma Java 1.4.2
✔ Preparat per a la plataforma Android i per a Google App Engine.
✔ Sense dependències. No li cal cap jar addicional.
✔ suport OAuth inclòs
✔ suport de GZip inclòs

Requeriments de sistema
Windows o Unix amb suport de Java.
JVM: Java 1.4.2 o superior

Com utilitzar Twitter4J?
Només cal afegir twitter4j-core-2.2.5.jar al classpath de l'aplicació.
El millor lloc per on començar és llegir el JavaDoc
El millor lloc per on començar a llegir el JavaDoc és la interface twitter4j.Twitter."

Però potser el primer que cal per a poder treballar amb Twitter és conèixer el protocol per a autenticar-se amb el servei: El protocol OAuth (rfc5849). Podem consultar també a http://oauth.net/core/1.0/.

El document de la rfc5849 ocupa 39 pàgines. però en un primer moment no cal llegir-lo per a poder fer servir la Twitter4J, perquè els detalls del funcionament estan encapsulats a la llibreria.

El que sí que caldrà és registrar l'aplicació que estem construint al servei Twitter, per a que aquest la reconegui i sigui capaç d'identificar-ne l'origen dels tweets. Això es fa a l'adreça https://dev.twitter.com/apps/new

Al formulari de registre haurem de posar el nom de l'aplicació, la descripció, l'adreça de descàrrega de l'aplicació (si la té)...

També hi podrem posar una icona, el tipus d'accés...el registre no resulta complicat.

Un cop registrada l'aplicació obtindrem les claus per autoritzar l'aplicació al Twitter.

En el llenguatge de OAuth un Consumer és una aplicació, o una web, que accedeix a un proveïdor de servei en representació d'un usuari. Al registrar l'aplicació obtindrem el parell de valors que ens caldran per a autenticar l'aplicació, o consumer:

Consumer Key: Un valor utilitzat per l'aplicació per a identificar-se ella mateixa enfront del servei Twitter (el "login" de l'aplicació).
Consumer Secret: Un valor secret utilitzat per l'aplicació per a certificar la propietat de la Consumer Key (el password).

A més, se'ns proporcionarà un conjunt d'URLs a les que caldrà accedir per a que l'usuari que faci servir l'aplicació també pugui autenticar-se

Request token URL: https://api.twitter.com/oauth/request_token
Authorize URL: https://api.twitter.com/oauth/authorize
Access token URL: https://api.twitter.com/oauth/access_token

Aquestes adreces permetran el diàleg entre el consumer i el servei per a autenticar a l'usuari final.

Request Token: és un valor utilitzat pel Consumer per a obtenir autorització de l'usuari i que es tradueix en un Access Token.
Access Token: és un valor utilitzat pel Consumer per a obtenir accés als Protected Resources (en el cas del Twitter, als tweets emesos o adreçats a l'usuari) en representació de l'usuari, en comptes de fer servir les pròpies credencials de l'usuari al Servei. És dir, l'aplicació no fa servir directament el login i el password de twitter de l'usuari. Podriem dir que l'Access Token és un login temporal.
Access Token Secret: un valor secret utilitzat pel Consumer per a certificar la propietat de l'Access Token (seria el password temporal corresponent al login temporal).

En la pàgina que es registra l'aplicació també podem obtenir un Acces Token i un Access Token Secret que es poden fer servir directament a l'aplicació per a piular des del propi compte de Twitter.

Guardem molt bé els diferents tokens rebuts. I mantinguem en secret els "passwords"
Finalment, un cop registrada l'aplicació, podrem veure la nova aplicació registrada (i totes aquelles altres que puguem tenir) a https://dev.twitter.com/apps

A la pàgina de Twitter4J ens diuen com fer servir aquests parells.

Amb un fitxer de propietats estàndard: twitter4j.properties. Cal que el fitxer "twitter4j.properties" es trobi a les rutes del classpath.

debug=true
oauth.consumerKey=*********************
oauth.consumerSecret=******************************************
oauth.accessToken=**************************************************
oauth.accessTokenSecret=******************************************

Amb un objecte ConfigurationBuilder

ConfigurationBuilder cb = new ConfigurationBuilder();
cb.setDebugEnabled(true)
.setOAuthConsumerKey("*********************")
.setOAuthConsumerSecret("******************************************")
.setOAuthAccessToken("**************************************************")
.setOAuthAccessTokenSecret("******************************************");
TwitterFactory tf = new TwitterFactory(cb.build());
Twitter twitter = tf.getInstance();

O amb variables de sistema passades a la JVM.

$ java -Dtwitter4j.debug=true
-Dtwitter4j.oauth.consumerKey=*********************
-Dtwitter4j.oauth.consumerSecret=******************************************
-Dtwitter4j.oauth.accessToken=**************************************************
-Dtwitter4j.oauth.accessTokenSecret=******************************************
-cp twitter4j-core-2.2.5.jar:yourApp.jar yourpackage.Main

Arribats a aquest punt, un cop obtinguts els parells Consumer Key, Consumer Secret i Access Token i Access Token Secret ja estic en condicions de fer una petita aplicació amb java que "Piuli" al twitter en nom del meu compte.

Una cosa tan senzilla com això:

package com.sticipl.proves;

import twitter4j.Status;
import twitter4j.Twitter;
import twitter4j.TwitterException;
import twitter4j.TwitterFactory;
import twitter4j.conf.ConfigurationBuilder;

public final class ProvaTwitter {
/**
* Usage: java twitter4j.examples.tweets.UpdateStatus [text]
*
* @param args message
*/
public static void main(String[] args) {
try {
ConfigurationBuilder cb = new ConfigurationBuilder();
cb.setDebugEnabled(true)
.setOAuthConsumerKey("[El consumer Key obtingut]")
.setOAuthConsumerSecret("[el consumer secret obtingut]")
.setOAuthAccessToken("[l'access token obtingut]")
.setOAuthAccessTokenSecret("[l'access token secret obtingut]");
TwitterFactory tf = new TwitterFactory(cb.build());
Twitter twitter = tf.getInstance();

Status status = twitter.updateStatus("Aquest és el missatge enviat des de l'aplicació #Java de prova fent us de #Twitter4J");
System.out.println("Actualitzat status a [" + status.getText() + "].");
System.exit(0);
} catch (TwitterException te) {
te.printStackTrace();
System.out.println("Excepció de Twitter: " + te.getMessage());
System.exit(-1);
}
}
}

En executar aquesta mini-aplicació, obtinc:

Actualitzat status a [Aquest és el missatge enviat des de l'aplicació #Java de prova fent us de #Twitter4J].

I en anar a Twitter puc comprovar que, efectivament, així és:

En aquesta primera aproximació a Twitter4J he fet un petit "piulador" personal. En un proper post presentaré un "Piulador" general.

Com instal·lar XAMPP a Ubuntu.

2011-10-28T23:49:00.002+02:00

A l'hora de fer presentacions i demos d'aplicacions web, pot ser molt útil disposar d'una versió de la demo en un servidor web en localhost, potser en una clau usb.

També pot ser molt útil un servidor web d'aquest tipus a l'hora de preparar sessions de formació.

És possible trobar per Internet diverses distribucions que d'aquest tipus que combinen Apache amb MySQL i PHP, tant sobre Linux (LAMP), com sobre Windows (WAMP), per exemple XAMPP o MoWeS Portable.

MoWeS Portable empaqueta, a més de la plataforma AMP, altres aplicacions que utilitzen aquesta infraestructura, com Joomla! o Drupal. Ara bé, MoWeS Portable només està disponible per a Windows.

XAMPP, en canvi, s'ofereix per a Linux i Windows.

En el post d'avuí el que faig és instal·lar el XAMPP a un netbook Linux.

No cal dir que la plataforma AMP es pot instal·lar des del Centre de Programari de l'Ubuntu. Però la instal·lació de XAMPP és encara més senzilla.

Dit i fet. El primer pas és descarregar-se el paquet d'instal·lació. El puc trobar en aquesta adreça: http://sourceforge.net/projects/xampp/files/BETAS/xampp-linux-1.7.7.tar.gz/download. Són uns 77MB.

Aquesta versió incorpora: Apache, MySQL, PHP amb PEAR, Perl, ProFTPD, phpMyAdmin, OpenSSL, GD, Freetype2, libjpeg, libpng, gdbm, zlib, expat, Sablotron, libxml, Ming, Webalizer, pdf class, ncurses, mod_perl, FreeTDS, gettext, mcrypt, mhash, eAccelerator, SQLite i IMAP C-Client.

En particular Apache 2.2.21, MySQL 5.5.16, PHP 5.3.8, i phpMyAdmin 3.4.5.

Per instal·lar n'hi ha prou amb desempaquetar el tar.gz. Cal tenir en compte que als fitxers d'instal·lació s'assumeix que la home del XAMPP serà /opt/lampp. Això NO vol dir que només es pugui instal·lar en aquesta carpeta. Això l'únic que vol dir és que caldrà que /opt/lampp sigui la "home" del XAMPP i això es podrà aconseguir amb un enllaç simbòlic des de /opt/lampp al directori d'instal·lació que triï.

Si la carpeta de destinació del XAMPP es troba en una clau usb caldrà que aquesta clau estigui formatada amb un sistema de fitxers que permeti els enllaços simbòlics, per exemple ext2,ext3 o ext4.

A l'hora de fer l'enllaç simbòlic caldrà tenir en compte el punt de muntatge del dispositiu. Per exemple, al meu netbook amb Ubuntu 11.04, el punt de muntatge és /media.

Per a poder instal·lar correctament el XAMPP caldran, a més, permisos de root. I també per a posar en marxa i aturar els diversos components de la distribució.

Tenint en compte tot l'anterior, instal·lo el XAMPP a la meva carpeta home, on he deixat el tar.gz:

sudo tar xvfz xampp-linux-1.7.7.tar.gz -C .

Amb la ordre anterior es crea una carpeta lampp amb els dversos components del XAMPP.

Ara creo l'enllaç simbòlic:

sudo ln -s /home/albert/lampp /opt/lampp

I engego per primer cop el servidor. Aquesta primera arrencada acaba d'instal·lar i configurar els components.

albert@athena:~$ sudo /opt/lampp/lampp start
Starting XAMPP for Linux 1.7.7...
XAMPP: Starting Apache with SSL (and PHP5)...
XAMPP: Starting MySQL...
XAMPP: Starting ProFTPD...
XAMPP for Linux started.
albert@athena:~$

I per revisar la nova instal·lació en tinc prou amb obrir un navegador i apuntar-lo al localhost:

El directori arrel del servidor web es troba a /opt/lampp/htdocs (en el meu cas, mercès a l'enllaç simbòlic, és /home/albert/lampp/htdocs).

Per aturar el XAMPP puc fer:

albert@athena:~$ sudo /opt/lampp/lampp stop
Stopping XAMPP for Linux 1.7.7...
XAMPP: Stopping Apache with SSL...
XAMPP: Stopping MySQL...
XAMPP: Stopping ProFTPD...
XAMPP stopped.
albert@athena:~$

I per a eliminar la instal·lació sense deixar rastres, amb el XAMPP aturat, n'hi ha prou amb fer:

sudo rm -r lampp

És possible engegar i aturar individualment els diversos components del XAMPP. Examinant el fitxer $HOME/lampp/lampp es poden trobar les diverses opcions disponibles. La forma d'invocar-les, en general, és:

sudo /opt/lampp/lampp opció

Com accedir a bases de dades SQLite amb Python

2011-10-09T14:55:00.002+02:00

En l'exercici d'avui, presento el mòdul pysqlite2 que proporciona una senzilla interfície per a utilitzar SQLite amb Python.

A l'Ubuntu, per a afegir aquest mòdul n'hi ha prou amb anar al Centre de Programari de l'Ubuntu i instal·lar els paquets python-pysqlite2 i python-pysqlite2-doc.

Cal anar amb compte perquè els números de versió poden crear confusió: trobarem també els mòduls python-pysqlite, però aquests són per a taules de l'anterior SQLite2. Els python-pysqlite2, corresponen a SQLite3, que és la versió actual.

Primer de tot crearé una base de dades SQLite3 de proves amb una taula diccionari. amb tres columnes: id, PK, numèric amb autoincrement; nom, text; valor, text.

La taula es pot crear de forma senzilla amb l'aplicació gràfica SQLiteman, que permet operar amb taules d'SQLite3. En tot cas, també es pot crear la taula de proves amb la interfície en mode text que proporciona el mateix SQLite3. En cas de no disposar de SQLiteman, aquest es pot instal·lar, com tota la resta, des del Centre de Programari de l'Ubuntu.

L'esquema

CREATE TABLE "diccionari" (

"id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,

"nom" TEXT NOT NULL,

"valor" TEXT NOT NULL

);

CREATE TABLE sqlite_sequence(name,seq);

Un cop creada la taula, la informo amb dades de prova.

I, a continuació, el codi per a afegir, cercar, esborrar...amb Python i pysqlite2.

#!/usr/bin/python

# coding: latin-1

# python i sqlite

from pysqlite2 import dbapi2 as sqlite

# es connecta a una base de dades

con = sqlite.connect("./prova-sqlite.db")

# itera a través de la taula diccionari amb un cursor

cursor = con.cursor()

# executa el cursor

cursor.execute("select id, nom, valor from diccionari")

# itera a través de les files

# obtenir-ne només resultat un:

print "\n-------------------------------"

print "estat inicial"

for fila in cursor:

# recupera els valors

iddic, nom, valor = fila[0], fila[1], fila[2]

# els mostra

print "id: " + str(iddic) + "; nom: " + nom + "; valor: " + valor

# inserta noves files, amb una seqüència

print "\n-------------------------------"

print "insereix 3 files"

cursor.execute("insert into diccionari(nom, valor) values (?, ?)", ("nom6","valor6") )

cursor.execute("insert into diccionari(nom, valor) values (?, ?)", ("nom7","valor7") )

cursor.execute("insert into diccionari(nom, valor) values (?, ?)", ("nom8","valor8") )

# commit

con.commit();

# a veure què ha fet...

cursor.execute("select id, nom, valor from diccionari")

# itera a través de les files

for fila in cursor:

# recupera els valors

iddic, nom, valor = fila[0], fila[1], fila[2]

# els mostra (un mètode alternatiu)

print "id: %d; nom: %s; valor: %s" % (iddic, nom, valor)

# amb un mapeig

print "\n-------------------------------"

print "insereix 3 files més"

item = {"nom": "nom9", "valor": "valor9"}

cursor.execute("insert into diccionari(nom, valor) values (:nom, :valor)", item)

item = {"nom": "nom10", "valor": "valor10"}

cursor.execute("insert into diccionari(nom, valor) values (:nom, :valor)", item)

item = {"nom": "nom11", "valor": "valor11"}

cursor.execute("insert into diccionari(nom, valor) values (:nom, :valor)", item)

# commit

con.commit();

# tornem a veure què ha fet...

cursor.execute("select id, nom, valor from diccionari")

# itera a través de les files

for fila in cursor:

# recupera els valors

iddic, nom, valor = fila[0], fila[1], fila[2]

# els mostra

print "id: %d; nom: %s; valor: %s" % (iddic, nom, valor)

#finalment, ho deixo tot com estava al començament

cursor.execute("delete from diccionari where id > 5")

con.commit()

# ho verifica...

cursor.execute("select id, nom, valor from diccionari")

# itera a través de les files, un mètode alternatiu amb fetchone

print "\n-------------------------------"

print "ho deixa com estava a l'inici"

fila = cursor.fetchone()

while (not (fila is None)):

# recupera els valors

iddic, nom, valor = fila[0], fila[1], fila[2]

# els mostra

print "id: %d; nom: %s; valor: %s" % (iddic, nom, valor)

fila = cursor.fetchone()

# tanca el cursor

cursor.close()

# tanca la connexió

con.close()

Els comentaris del codi en proporcionen les explicacions. Només en destacaria les alternatives idiomàtiques que ofereix Python per a realitzar diverses accions:

Per exemple: un print de diferents variables, i l'alternativa a l'estil del printf de C:

print "id: " + str(iddic) + "; nom: " + nom + "; valor: " + valor

print "id: %d; nom: %s; valor: %s" % (iddic, nom, valor)

O aquesta altre: la iteració a través d'un cursor amb for, i uns alternativa amb while

amb for

for fila in cursor:

# recupera els valors

iddic, nom, valor = fila[0], fila[1], fila[2]

# els mostra

print "id: %d; nom: %s; valor: %s" % (iddic, nom, valor)

amb while:

fila = cursor.fetchone()

while (not (fila is None)):

# recupera els valors

iddic, nom, valor = fila[0], fila[1], fila[2]

# els mostra

print "id: %d; nom: %s; valor: %s" % (iddic, nom, valor)

fila = cursor.fetchone()

Instruccions "preparades" i l'ús de '?', o de variables vinculades a l'insert

amb '?'

cursor.execute("insert into diccionari(nom, valor) values (?, ?)", ("nom6","valor6") )

amb variables vinculades

item = {"nom": "nom11", "valor": "valor11"}

cursor.execute("insert into diccionari(nom, valor) values (:nom, :valor)", item)

I, a continuació, una execució del programa

albert@atenea:~/wk-python/prova-sqlite$ python prova-sqlite.py

-------------------------------

estat inicial

id: 1; nom: nom1; valor: valor1

id: 2; nom: nom2; valor: valor2

id: 3; nom: nom3; valor: valor3

id: 4; nom: nom4; valor: valor4

id: 5; nom: nom5; valor: valor5

-------------------------------

insereix 3 files

id: 1; nom: nom1; valor: valor1

id: 2; nom: nom2; valor: valor2

id: 3; nom: nom3; valor: valor3

id: 4; nom: nom4; valor: valor4

id: 5; nom: nom5; valor: valor5

id: 45; nom: nom6; valor: valor6

id: 46; nom: nom7; valor: valor7

id: 47; nom: nom8; valor: valor8

-------------------------------

insereix 3 files més

id: 1; nom: nom1; valor: valor1

id: 2; nom: nom2; valor: valor2

id: 3; nom: nom3; valor: valor3

id: 4; nom: nom4; valor: valor4

id: 5; nom: nom5; valor: valor5

id: 45; nom: nom6; valor: valor6

id: 46; nom: nom7; valor: valor7

id: 47; nom: nom8; valor: valor8

id: 48; nom: nom9; valor: valor9

id: 49; nom: nom10; valor: valor10

id: 50; nom: nom11; valor: valor11

-------------------------------

ho deixa com estava a l'inici

id: 1; nom: nom1; valor: valor1

id: 2; nom: nom2; valor: valor2

id: 3; nom: nom3; valor: valor3

id: 4; nom: nom4; valor: valor4

id: 5; nom: nom5; valor: valor5

albert@atenea:~/wk-python/prova-sqlite$

Per saber-ne més, una cerca a Google ens proporcionarà un munt d'enllaços. Tanmateix, cal explicitar la referència fonamental: el lloc de la documentació de Python (http://docs.python.org).

En particular, l'apartat de SQLite 3: http://docs.python.org/library/sqlite3.html

10a Diada de les Telecomunicacions a Catalunya.

2011-09-30T00:47:00.001+02:00

Avui -29 de setembre, Sant Gabriel, patró de les Telecomunicacions- s'ha celebrat la 10a Diada de les Telecomunicacions a Catalunya.

Organitzat pel COETTC, es tracta d'un esdeveniment important dins el món TIC al nostre país.

Com podem llegir a la mateixa web del esdeveniment:

"La Diada està orientada als professionals del sector TIC: empresaris, directius, universitaris, comercials i polítics relacionats amb les TIC. També s’adreça als estudiants d'enginyeria i FP, i a tots aquells que tinguin inquietud per estar al dia en el sector TIC.

A la Diada es pren el pols al Sector; s'analitza el que ha estat l'últim any, i es fa una prospecció del que serà el futur immediat. Les diferents ponències no són panells d'alt contingut científic, sinó exposicions i plantejaments de tendències futures: tot això amb un llenguatge fàcil i assequible."

Dins els marc de la Diada, al CosmoCaixa de Barcelona s'han dut a terme diverses activitats,

Conferencia inaugural.
Taules rodones.
Networking, facilitant als assistents diversos moments per a relacionar-se, comunicar-se i fer negocis entre ells.
El lliurament dels Premis Excel·lència a les Telecomunicacions, després de l'acte de cloenda

Les diverses activitats de la Diada han pogut preparar-se i seguir-se online per les xarxes socials Twitter, FaceBook i LinkedIn