El canton de Marco (Marco's corner)

Jolie on Azure Functions

2020-06-04T14:07:00.001+02:00

Hi all. Some weeks ago Azure Functions' team released (as a preview) custom handlers.
From the official doc:

Custom handlers are best suited for situations where you want to:

Implement a function app in a language that's not officially supported.

Implement a function app in a language version or runtime not supported by default.

Provide more granular control over the function app execution environment.

I think this is a really powerful feature and you can actually find a lot of articles showing how to leverage it to write functions in Go, PHP, etc
Now I'm going to add yet another programming language to the list: Jolie.
Again, from the documentation:

To implement a custom handler, you need the following aspects to your application:

A host.json file at the root of your app

A function.json file for each function (inside a folder that matches the function name)

A command, script, or executable, which runs a web server

In addition, you have to supply all is needed for your function to run because we are going to deploy to a stateless environment (obviously JDK support is required on the target platform as Jolie is Java dependent).
I added a full Jolie distribution (what you find in JOLIE_HOME path) to my function project in jolie_bin directory and modified the launch script to point to it.

So my host.json looks like that:

{
"version": "2.0",
"httpWorker": {
"description": {
"arguments": ["jolie_services.ol"],
"defaultExecutablePath": "jolie_func_executor.sh"
},
"extensionBundle": {
"id": "Microsoft.Azure.Functions.ExtensionBundle",
"version": "[1.*, 2.0.0)"
}
}
}

where jolie_services.ol actually contains the function's code.

Jolie native support for HTTP protocol makes it really easy to write a "webserver".

Unfortunately there's a problem because Azure Functions Host communicates with custom handlers on a dynamic port, on which your application has to be listening.
This port can be read by the FUNCTIONS_HTTPWORKER_PORT environment variable but when you define an InputPort in Jolie the Location parameter is static, for instance:

inputPort MyInput {
Location: "socket://localhost:8180"
Protocol: http
Interfaces: MyInterface
}

Dynamic Locations aren't yet available in Jolie but there's a workaround using a constant.

In Location's definition, we refer to this constant:

Location: AzureFunctionsPort

In the launch command, we read the environment variable and pass it to our Jolie program setting the constant value:

-C AzureFunctionsPort="\"socket://localhost:$FUNCTIONS_HTTPWORKER_PORT\""

Here you can find a simple working example with detailed instructions to start from scratch.

Jolie micro services on Kubernetes

2020-03-15T19:31:00.000+01:00

Jolie is a (micro) service-oriented language.
Jolie's capabilities work well with Docker and you can find an example in the official documentation here.
So deploying a Jolie service in a Docker container is quite easy.
Now it's time to go onboard with Kubernetes ;-)

This is only a little demo on how to set up a Kubernetes environment on your PC (thanks to minikube) and build up a scalable clusterized version of Jolie's "Hello world" example.

You can find Jolie examples on this GitHub project.

What we are going to do now is to transform "01_getting_started" sample (which simply twices a number) into a powerful Kubernetes scalable app (doing exactly the same thing, but in a cool way).

If you object that this is very unreasonable, I have to remind you that it is perfectly aligned with today's software industry standards. :-P

To be honest I'm not going to explain what Kubernetes is and how it does what it does, so please go read a tutorial or the beautiful official documentation.

My favourite starting point is this (it's not a joke).

First of all, let's set up your box!
You need:

Linux (tested on Ubuntu 18.04) or Windows 10 Pro (tested on 1909) with HyperV support enabled
Jolie language
Docker
Minikube (on Win10 I suggest you to force version 1.5.0 installation to avoid some fresh annoying bugs)

Ok, ready?

Now you can clone this repository and go ahead.

STEP 1 - Create a Docker image containing your Jolie application

As previously said this is very simple following the official documentation and using images available on Docker Hub.

This is our Dockerfile to build an image exposing the "twice-a-number" server on 8000 port:

FROM jolielang/jolie

EXPOSE 8000

COPY server.ol server.ol

COPY twiceInterface.iol twiceInterface.iol

CMD jolie server.ol

Before creating the image we have to configure Docker's environment to point to minikube, otherwise images wouldn't be available to your local cluster.

Linux

$ eval $(minikube docker-env)

Win10 (on PowerShell)

PS> & minikube docker-env | Invoke-Expression

Ok, now we can build our image (if not specified commands are the same on both platforms, don't miss the final dot):

$ docker build -t jolie-k8s-sample .

and verify all went as expected:

$ docker images

REPOSITORY TAG IMAGE ID

jolie-k8s-sample latest 2df927523a30 ...

STEP 2 - Create a Kubernetes deployment

So we are ready to use our brand new image in a Kubernetes deployment, setting replicas parameter to 2.

This means Kubernetes ensures to have always 2 pods (the furry blue little animals Phippy introduced to you) running our container.

apiVersion: apps/v1
kind: Deployment
metadata:
name: jolie-sample-deployment
labels:
app: jolie-sample
spec:
replicas: 2
selector:
matchLabels:
app: jolie-sample
template:
metadata:
labels:
app: jolie-sample
spec:
containers:
- name: jolie-k8s-sample
image: jolie-k8s-sample
ports:
- containerPort: 8000
imagePullPolicy: IfNotPresent

To start deployment roll-out just type:

$ kubectl apply -f jolie-k8s-deployment.yml

And after a few seconds you can see your pods up and running:

$ kubectl get pods

NAME READY STATUS RESTARTS AGE

jolie-sample-deployment-655f8b759d-bmzk7 1/1 Running 0 4s

jolie-sample-deployment-655f8b759d-mq8cn 1/1 Running 0 4s

Exciting!

STEP 3 - Expose deployment by a service

Now we have 2 running instances of our (micro)service but we lack a communication channel to reach the container's port 8000 from outside of Kubernetes virtual network.
Kubernetically speaking this is a service.
Just follow the minikube tutorial and type:

$ kubectl expose deployment jolie-sample-deployment --type=LoadBalancer --port=8000

$ kubectl get services

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE jolie-sample-deployment LoadBalancer 10.109.47.147 <pending> 8000:30095/TCP 13s kubernetes ClusterIP 10.96.0.1 <none> 443/TCP

So there's a service exposing pods' port 8000 on cluster's port 30095.

To make this visible from your host you have to go through a "minikube service":

$ minikube service jolie-sample-deployment

|-----------|-------------------------|-------------|-----------------------------| | NAMESPACE | NAME | TARGET PORT | URL | |-----------|-------------------------|-------------|-----------------------------| | default | jolie-sample-deployment | | http://192.168.99.100:30095 | |-----------|-------------------------|-------------|-----------------------------|

* Opening service default/jolie-sample-deployment in default browser...

Close the automatically opened browser and let's go on.

Step 4 - Invoke micro services from client

As final step we want to call the Jolie service running inside Kubernetes cluster.
Open client.ol with a text editor and modify line 5, setting IP and port of exposed minikube service:

Location: "socket://192.168.99.100:30095"

Save and try:

$ jolie client.ol jolie-sample-deployment-655f8b759d-mq8cn -> 10 $ jolie client.ol jolie-sample-deployment-655f8b759d-bmzk7 -> 10 $ jolie client.ol jolie-sample-deployment-655f8b759d-mq8cn -> 10 $ jolie client.ol jolie-sample-deployment-655f8b759d-bmzk7 -> 10

As you can see we are getting the right response (client.ol has an hardcoded 5 value as input) and so we demonstrated Kuberntes can at least multiply an integer by another integer!
But server.ol running on containers was modified from the example's original to write out the hostname too:

getenv@Runtime( "HOSTNAME" )( hostname_env ) result = hostname_env + " -> " + number * 2

And that allow us to verify that:

our Jolie server is running on multiple pods
the infrastructure is hidden to clients
calls are automatically managed and balanced by Kubernetes engine (output shows each call gets its response from different pod)
BONUS if you need more power to multiply number 5 you can scale up your deployment:
$ kubectl scale deployment jolie-sample-deployment --replicas=<N>

Kubernetes NGINX Ingress - Automating dynamic rules management

2019-04-18T10:46:00.001+02:00

A few points to ensure you're interested in this argument.

You set up a Kubernetes cluster where you deployed your brand new containerized application.
You set up an NGINX based Ingress to expose it and manage TLS termination.
You need to handle a lot of routing rules (growing from some to thousands) and, more important, you need automation.

I assume steps 1 and 2 are done, so let's dive in rules management and its automation.

The first option Kubernetes gives you is this cli command:

kubectl edit ingress <your_ingress_name>

An editor comes up you can modify the ingress resource, when you save the configuration is automatically updated.

That's ok and really useful, but not suitable if you need automation, and a DevOps guy should automate everything! :-P

So I've found resources can also be patched, supplying a json string.

As an example you can create a file with json patch definition:

[{
"op": "add",
"path": "/spec/rules/-",
"value": {
"host": "<your_url>",
"http": {
"paths": [
{
"backend": {
"serviceName": "<your_dest_service>",
"servicePort": your_service_port
}
}
]
}
}
}]

And apply it to your resource:

kubectl patch ingress <your_ingress> --type json -p "$(cat <your_json_file>"

This appends the new rule to rules array in ingress definition, see JSON Patch format details here.
The great advantage is that you focus on a single rule and the process can be easily automated.
I faced some more difficulties when I first tried to remove a rule.
Obviuosly you can edit the entire ingress definition, manually remove the lines regarding the rule to be removed and save.
But what about automation?
This is my solution using again Kubernetes' patching capabilities.
The main idea is to leverage the JSON Patch replace operation.
For instance this command removes the first rule from your Ingress:

kubectl patch ingress <your_ingress> --type json -p "[{\"op\": \"remove\", \"path\": \"/spec/rules/0\"}]"

Unfortunately JSON Patch supports only positional path for arrays, so my problem was to get the target rule position inside rules array.
I achieved that using jq command:

kubectl get ingress <your_ingress> -o json | jq ".spec.rules | map(.host == \"<url_to_be_removed>\") | index(true)"

So, putting all together, this Bash script does the trick:

#!/bin/bash
index=$(kubectl get ingress <your_ingress> -o json | jq ".spec.rules | map(.host == \"<url_to_be_removed>\") | index(true)");
kubectl patch ingress <your_ingress> --type json -p "[{\"op\": \"remove\", \"path\": \"/spec/rules/$index\"}]";

Now you can use this technique in your favourite automation environment.
As an example I've created a couple of Ansible roles, but the real work is done by Bash scripts (no Ansible modules available).

Ansible, Azure & WSL survival guide (VS Code bonus track)

2018-12-06T15:37:00.004+01:00

Hi all you new DevOps!
This guide is meant for poor Windows' users struggling to get Ansible working on their workstations, like me few days ago :-(
Scenario: you're involved in a brand new cloud project on Azure, you're trying to make things work with Ansible and your company provides you a Windows 10 ™ PC, but Ansible DO NOT RUN on Windows.
In addiction you're lazy and bored to start yet another virtual machine, just to type "git pull" and "ansible-palybook" :-D (by the way your precious SSD is getting dangerously full).
And you do want your memory greed Visual Studio Code, with autocompletion, syntax highlight, all-known languages modules and other silly stuff.

First of all, let's install WSL (if you don't know what WSL is, google it):
https://docs.microsoft.com/en-us/windows/wsl/install-win10
I assume you installed an Ubuntu 16.04 upon WSL.
Quite simple, isn't it?
Now you should install Ansible and all needed Azure modules.
There's a simple guide on Azure documentation portal, let's follow the Ubuntu's section.
Uhm, did something go wrong with pip's version and other Python related stuff?
Ok, you may have SSL certificates issues or pip/Python versions hell (damn it).
Try to substitute this command:

sudo pip install ansible[azure]

with:

pip install pip==9.0.3 --trusted-host=pypi.python.org --trusted-host=pypi.org --trusted-host=files.pythonhosted.org --user
pip install ansible --trusted-host=pypi.python.org --trusted-host=pypi.org --trusted-host=files.pythonhosted.org --user
pip install azure --trusted-host=pypi.python.org --trusted-host=pypi.org --trusted-host=files.pythonhosted.org --user
pip install ansible[azure] --trusted-host=pypi.python.org --trusted-host=pypi.org --trusted-host=files.pythonhosted.org --user

and cross your fingers, it worked for me.
And now the last tips to make you an happy hybrid environment developer.

Ansible complains you're reading the config from from a world-writable current working directory? Go there and follow the instructions you find here to properly mount Windows disk.
You edit files in your WSL home directory from Windows and you loose ownership, permissions, etc ?
Go there and there (a bit technical).
And finally enjoy coding with VS Code
I had to specify C:\WINDOWS\System32\wsl.exe as integrated shell path (bash.exe didn't work for me).

Faa(m)s - Fuffa as a microservice [seconda parte]

2018-04-08T17:55:00.000+02:00

Dopo aver esplorato in maniera pressoché esaustiva nel post precedente la potenza del Serverless Cloud Computing, in questa seconda puntata ho pensato di orientarmi verso altre 2 tematiche-totem dell'informatica contemporanea: la cross-platformitidune e l'architettura a microservizi.
Qualunque progetto che ambisca ad essere al passo con i tempi non può prescindere da queste buzzwords!
In realtà il punto cross-platform era già stato smarcato mentre preparavo il materiale per il primo post: grazie all'avvento di .NET Core è stata M$ stessa a risolvere la questione alla radice.
L'unico problema era portare la libreria TinyGrammar da .NET Framework a .NET Core (anzi a .NET Standard per essere precisi), per fortuna la cosa si è rivelata molto semplice seguendo questa guida.
Libreria e unit test non hanno praticamente richiesto nessuna modifica, la console app l'ho dovuta riscrivere, nel senso che ho dovuto fare copia e incolla dentro il progetto vuoto di VS2017:

A breve pubblicherò su GitHub il progetto completo, appena gli avrò dato una sistemata, giusto quel tanto che basta per non essere citato nel gruppo Facebook "I peggiori programmatori di merda".
Avendo quindi agevolmente fatto il porting su Linux/Mac non restava che imboccare con tracotanza la strada verso una modernissima architettura a microservizi, stuzzicato dalla critica del mio fratellino professore: "Divertente, ma manca una versione international, almeno in inglese..."
Come dargli torto!
A quel punto ho deciso di stare sulle spalle dei giganti (spiegone):

usare il servizio di traduzione di Google
usare il linguaggio nativamente orientato ai servizi, Jolie

Per fortuna qualcuno aveva già trovato il modo di utilizzare le API di Google Translate senza passare per il servizio business, va bene la modernità, ma meglio se aggratis.

Seguendo l'approccio monolith first ben descritto da Fabrizio in salsa Jolie, ho scritto una manciata di righe (scopiazzate da qua) per redirigere l'output di TinyGrammar al servizio di traduzione:

Se la sintassi di Jolie vi risulta poco familiare, scaricatelo e studiatelo, in un paio d'ore sarete dei maestri :-P
Questo incoraggiante esempio di fast software prototyping mi ha portato al secondo step, ovvero la realizzazione di un elegante microservizio HTTP che trovate qua.
Nessun container, nessun host, just works!
Per chi obiettasse che non c'è la benché minima traccia di fault handling rispondo che si tratta di throwaway prototyping :-P
E per sfregio ritorno un vetusto XML che solo a vederlo si sente puzza di legacy.
Ovviamente per il corretto funzionamento avrete bisogno di Jolie e di .NET Core

FaaS - Fuffa as a Service [Prima parte]

2018-03-25T18:10:00.000+02:00

Qualche tempo fa qualcuno mi ha segnalato questa pagina:
http://www.massimobarbieri.it/it/Tecnichese/
In pratica si tratta di un sofisticato generatore di supercazzole in gergo tecnico, basato su solide basi teoriche (guardate anche l'altro esempio di utilizzo di TinyGrammar, ne vale la pena).
Dopo aver fatto diversi click sul pulsante "Genera altro tecnichese" ho constatato (con le lacrime agli occhi per le risate) che il tool è robusto ed affidabile :-P
Il contagio si è rapidamente sparso tra i colleghi, scatenando la facile ironia di chi faceva notare quanto le frasi generate fossero praticamente indistinguibili da alcuni discorsi sentiti durante serissime riunioni di lavoro.
A questo punto, siccome non so se sono più nerd o più cazzaro, mi sono accorto che Barbieri (grazie Massimo) ha pubblicato su GitHub la sua libreria con licenza GPL e che sarebbe stato facile modificare il dizionario della grammatica per renderlo ancora più affine al mio ambito aziendale (nomi di prodotti, team di sviluppo, tecnologie specifiche, etc).
In pochi minuti clono il progetto, compilo la console app e modifico il file di esempio della grammatica; il risultato è irresistibile: serpeggia anche l'idea di sostituire analisti e project manager con questo strumento economico e funzionale.
Tutto si sarebbe esaurito così se non fosse che negli ultimi mesi mi sto interessando di cloud computing; più di una volta, essendo un newbie, i discorsi degli esperti e la documentazione tecnica consultata mi sono sembrati delle incomprensibili supercazzole.
La mia sottile e perfida rivalsa sarebbe stata questa: avrei implementato un generatore di fuffa full cloud, stateless, serverless, intrinsecamente scalabile e cross platform, fruibile da web e da mobile app tramite una API REST.
Qua si serve solo migliore tecnologia mio pappa diceva (questa è un po' di nicchia, ma sta uscendo Ready Player One e citare gli anni '80 va di moda).
Nella prima puntata (si, perché ho altre idee in serbo) vediamo cosa si può fare su Azure e più in generale con l'ecosistema Micro$oft.
Per cominciare al giorno d'oggi NON puoi considerarti un moderno developer se non scrivi microservizi, preferibilmente su architettura serverless, su Azure mamma M$ ci mette a disposizione Azure Functions.
Dopo aver dato un'occhiata alle prime pagine della doc mi sembra che si possa creare in modo semplice una function che risponda a chiamate HTTP, bene, ci siamo.
Con una googlata trovo anche questo articolo che spiega passo passo come referenziare un assembly nella mia function: ottimo! Così riciclo la libreria TinyGrammar as is per ridurre notevolmente il time to market (notate la sapiente commistione di nerdese con alcune espressioni che possano compiacere l'eventuale project manager fuffoso).
A questo punto per fare il figo dovrei mettere i file di testo delle grammatiche su uno storage account e leggerlo dalla function, ma io sono pigro e quindi ficco dentro tutto il testo in una bella stringa :-P
Risultato funzionante (da notare la finezza che ritorno HTTP 200 anche se va in errore):

Sono serverless, stateless e useless, mi sento sulla cresta dell'onda.
Arrivati qua ci si potrebbe accontentare di puntare all'URL della nostra function per ottenere fuffa randomica sul nostro browser, ma come si fa a presentare un progetto senza UI? La user experience non è per nulla soddisfacente e non si dimostra di essere full stack!
Il primo esperimento è stato creare un sito statico sempre hostato su uno storage account di Azure, con una fetch() che richiama il nostro servizio il gioco è fatto e dimostro di avere notevoli competenze Javascript :-P
Ma se al giorno d'oggi non fornisci un'app mobile che sviluppatore sei? Probabilmente il mercato dell'industry 4.0 non ti si fila nemmeno.
Per fortuna ho anche un'account di Office 365 e avevo giocherellato con Microsoft Flow, che il client mobile già ce l'ha.
L'adozione di Flow non si deve certo alla mia innata pigrizia (nooo!) ma alla pervicace intenzione di non indulgere in dannosi anti-pattern, come il famigerato NIH.
Vabbè, insomma questo era pronto e con 4 click è venuto fuori questo gioiellino: Fuffa as a Service on demand con notifiche push su app mobile (vedi sotto)!
Nei prossimi episodi (in ordine sparso): conversione in .NET Standard e console app .NET Core per girare su Linux, porting su AWS, verie ed eventuali.
See you.

Jelly Bean on Toshiba Folio

2012-09-16T13:15:00.004+02:00

Only few weeks with ICS, it's time for Jelly Bean on my Folio!
I just followed the instructions on this post (only cache wipe required).
This ROM is CyanogenMod 10 based and works really fine.

By the way I did the entire procedure within the tablet, no PC need, just download, reboot and flash!

Yet another Folio update (ICS 4.0.4)

2012-08-20T11:16:00.000+02:00

Nell'ultimo articolo riguardante il mio povero Toshiba Folio avevo accennato al fatto che, per avere a disposizione il bluetooth, non avevo utilizzato l'ultima versione disponibile della ROM di Ice Cream Sandwich.

Purtroppo quella versione (alpha 4) si è rivelata piuttosto instabile e quindi, come suggerivo nell'articolo, sono passato alla alpha 5.

Basta semplicemente flashare (per sicurezza anche le Gapps) e fila tutto liscio: ha mantenuto le applicazioni, le impostazioni, la cache, tutto.

Purtroppo, per chi ne ha bisogno, niente bluetooth :(

Attendo con ansia Jelly Bean.

Autobahn part 1: installing on Opensuse

2012-07-27T18:16:00.001+02:00

As every web developer should do, I'm exploring the new wonderful capabilities of modern browsers.
On of the most powerful is websocket technology:
WebSocket is a web technology providing for bi-directional, full-duplex communications channels over a single TCP connection.
Nice, isn't it?
By the way I am learning Python and first examples are very boring, so I decided to try something really interesting: Autobahn.
From official site: Autobahn provides Open-Source client and server implementations of WebSocket and WAMP.
I thought this could be a good start point to improve knowledge of Python and websockets at the same time.
So I pointed to http://autobahn.ws/python/getstarted and followed the instructions, but on my OpenSuse 12.1 I couldn't get Autobahn installed.
In this first post you can find how to get it running.
The two suggested methods (from package and from source) have the same problem, so I'll use the package method, because there are less instructions to write and, you know, I'm lazy.
You should use the following command:

easy_install autobahn

but this produces errors about missing headers during compilation.
With a little help from Google I found how to get rid of these errors.
You have to install Python's development package (and GCC, if is not already installed):

zypper in python-devel
zypper in gcc

Now you can go on to the first example, which is perfectly working.
If you copy and paste the code into your editor you just have to modify line 29 in myclient.html removing the whitespace in </script> tag.
I'm reading the tutorials and I'll be back with something useful soon (hope so).

Chor, a brand new language

2012-07-16T15:02:00.000+02:00

Yes, yet another programming language: Chor
As the name suggests Chor is a new programming language for communicating systems, based on choreographies ( I'm not talking about dance of course :P ).
There are many reasons to give it a chance.
First of all is a creature of my brother Fabrizio, then because it's very promising and has solid formal foundations.
It's still in alpha state but you can see it in action in this video:

Nice job Fabrizio!

It's time for an Ice Cream Sandwich (on Toshiba Folio)

2012-06-19T18:35:00.001+02:00

Visto il caldo torrido che sta facendo ho pensato bene di rinfrescare il vecchio Toshiba Folio con un buon biscotto gelato :-)
In un vecchio post avevo descritto sommariamente la procedura che aveva portato Android 2.3.7 sul mio tablet, ora sono passato alla versione 4.0.3 (Ice Cream Sandwich, appunto).
Se l'altra volta ero stato stringato oggi lo sarò ancora di più: semplicemente scaricate ROM, Gapps e (soprattutto) la recovery di Nopy come descritto in questo post e seguite scrupolosamente le istruzioni.
Io per avere il bluetooth ho usato la Alpha 4, se non vi interessa vi consiglio la Alpha 5, che dovrebbe aver risolto qualche piccolo bug.
In ogni caso si tratta di pre-release di Cyanogen 9, quindi bugs e instabilità potrebbero essere sempre in agguato.
Se questo non vi spaventa in meno di mezz'ora ecco cosa vi aspetta:

PHP & Websockets

2012-06-19T10:22:00.000+02:00

Il supporto offerto dai browser "moderni" alle funzionalità HTML5 sta favorendo il fiorire di un numero impressionante di progetti volti a rendere più immediato il loro utilizzo con i linguaggi classici dello sviluppo web.
Una tecnologia molto interessante è quella dei websockets, in parole povere si tratta di un canale di comunicazione bidirezionale che si instaura tra browser e server, superando di fatto lo schema classico delle web apps (request-response).
Utilizzando principalmente PHP ho cercato cosa fosse stato realizzato in questo campo per il

PHP and WebSockets
Sembra che non sia più sviluppato attivamente.
WebSocket Server and Client library for PHP
Simile al precedente, non richiede altre librerie o componenti, progetto attivo.
Ratchet
Sembra il più ricco di funzionalità, sfrutta alcuni componenti di Symfony.

Spendo qualche parola in più su Ratchet perché mi ha fatto scoprire un altro tool interessante: composer, ovvero un dependency manager per PHP.

Pur essendo un progetto ancora giovane, Ratchet è molto ben strutturato e sfrutta diverse librerie, per cui gli sviluppatori hanno deciso di tagliare la testa al toro:

The best (and currently only) way to install Ratchet is using composer.

L'impatto non è stato semplice perché il classico approccio scarica/scompatta mi ha fuorviato e non riuscivo neanche ad eseguire gli esempi, che trovate qui.

Questo perché non solo Ratchet stesso deve essere installato con composer, ma anche il progetto con gli esempi (bastava notare il file composer.json nella root, che contiene tutte le informazioni sulle dipendenze)!

Insomma alla fine bastava scaricare i sorgenti e digitare:

$ php composer.phar install

per trovarsi un sistema funzionante (ovviamente dovete avere l'estensione phar di PHP).

Spero sia uno spunto interessante.

Lightbox workaround per pagine non completamente caricate

2012-06-14T16:48:00.001+02:00

Vi sarà capitato di usare Lightbox in una delle sue tante varianti o script simili per gestire lo zoom di immagini sui vostri siti.
Semplice, leggero, stilabile, tutto ok.
Purtroppo soffre di un piccolo problema, non lo chiamo bug perché la documentazione ufficiale recita:
It doesn't work if I click an image before the page has finished loading.

This is not a bug, but a side-effect of unobtrusive scripts of this kind.

Nella stragrande maggioranza dei casi questo non è un problema, ma a volte può essere fastidioso, soprattutto se la pagina per qualche motivo ha tempi di caricamento elevati.

Il mio caso è questo:

http://www.newgroove.it/articolo.php?item=1530&q=ROLAND-SPD-S

In fondo alla scheda prodotto viene caricata la thumbnail del sito del produttore, generata on the fly da un servizio web.

Se l'immagine non risulta nella cache del sistema deve essere generata (visitando la pagina web relativa) e l'operazione può richiedere qualche secondo.

Ovviamente nel frattempo Lightbox non funziona e se si clicca per eseguire lo zoom della foto del prodotto si ottiene il comportamento standard del browser per un link ad una immagine.

Dovrei usare l'imperfetto perché adesso il funzionamento è quello corretto, ho trovato un workaround, solo che non ho capito fino in fondo PERCHE' funziona :P

In realtà una soluzione "sensata" poteva essere questa: eseguire il caricamento della thumbnail tramite uno script PHP richiamato via Ajax, in questo modo il DOM sarebbe stato disponibile al completo anche prima del caricamento dell'immagine.

Invece ho provato una soluzione Javascript only, sfruttando jQuery.

Questo è il codice finale:

$(document).ready(function() {

initLightbox();

setTimeout("ShowThumb();",500);

});

Il metodo .ready() risolve parte del problema, come spiegato nella doc ufficiale:

While JavaScript provides the load event for executing code when a page is rendered, this event does not get triggered until all assets such as images have been completely received.

La funzione initLightbox() forza l'inizializzazione di Lightbox; poi non resta che richiamare la funzione ShowThumb(), che molto semplicemente setta l'attributo src dell'immagine che deve contenere la thumbnail.
Peccato che senza aggiungere il piccolo delay introdotto con setTimeout la cosa non funzionava; ho dato un'occhiata a cosa esegue initLightbox e ad "intuito" ho pensato che bastasse dare tempo all'interprete Javascript di terminare il ciclo sui tag <a> prima che l'altra funzione ne modificasse il contenuto.
Ogni buon programmatore non dovrebbe mai accontentarsi di una spiegazione del genere, malgrado la breve euforia per aver accontentato in qualche modo il cliente :D
Io continuo a pensarci, se qualche guru JS mi illumina gli sarò grato!

NodeJS e PHP, just for fun

2012-06-12T11:45:00.000+02:00

In questi giorni sto cercando di approfondire la conoscenza di Node.js ed ho iniziato con questo ottimo tutorial, veramente ben fatto.
Ovviamente, da bravo smanettone, dopo le prime N pagine mi sembrava di aver preso possesso dei concetti base e che fosse arrivato il momento di passare a qualche esempio "utile".
Ovviamente sono iniziate le grane...
Poiché sviluppo principalmente in PHP la mia idea era questa: realizzare con Node.js una sorta di dispatcher di eventi, per sostituire il long polling Ajax, lasciando la logica associata agli eventi negli script PHP.
Ho cominciato a cercare articoli e tutorial in rete e qualcosa ho combinato :)
Punto di partenza questo ottimo spunto di Gianluca Guarini, che implementa un push notification server con Node.js e socket.io; in pratica un semplice script Node.js gestisce la comunicazione con il client tramite websocket.
Partendo da questo schema ho aggiunto la possibilità di richiamare un servizio scritto in PHP, in risposta ad un evento intercettato da Node.js, tramite chiamata asincrona con jQuery.
L'unico vero problema incontrato è che il server Node.js sta in ascolto su una porta diversa da quella utilizzata da Apache per esporre i servizi scritti in PHP e quindi il browser blocca la comunicazione a causa della protezione per il cross domain scripting.
Per evitare questo inconveniente sono possibili 2 strade:

usare mod_rewrite per mascherare le richieste a Node.js come descritto qui, oppure sfruttare mod_proxy (esempio qui );
utilizzare JSONP per le chiamate Ajax.

Siccome la soluzione 1 non richiede alcuna modifica al codice mi sono divertito ad implementare la 2, garzie alle dritte che ho trovato in questo post.

Dopo qualche tentativo ecco il frutto delle mie fatiche ( ovviamente sono pigro e c'è un bel mix dei vari script, un po' in inglese, un po' in italiano :P ).

echo_service.php

1:  <?php  
2:  header("content-type: application/json");  
3:  echo $_GET['jsonp_callback']. '('. json_encode($_GET['message'].' alle '. Date("H:i:s")) . ')';   
4:  ?>

server.js

1:  var http = require('http')  
2:  , url = require('url')  
3:  , fs = require('fs')  
4:  , server;  
5:  server = http.createServer(function(req, res){  
6:    // your normal server code  
7:    var path = url.parse(req.url).pathname;  
8:    switch (path){  
9:      case '/':  
10:        res.writeHead(200, {'Content-Type': 'text/html'});  
11:        res.write('<h1>Hello! Try the <a href="/socketio-test.html">Socket.io Test</a></h1>');  
12:        res.end();  
13:        break;  
14:      case '/socketio-test.html':  
15:        fs.readFile(__dirname + path, function(err, data){  
16:        if (err) return send404(res);  
17:        res.writeHead(200, {'Content-Type': path == 'json.js' ? 'text/javascript' : 'text/html'})  
18:        res.write(data, 'utf8');  
19:        res.end();  
20:        });  
21:        break;  
22:      default: send404(res);  
23:    }  
24:  }),  
25:  send404 = function(res){  
26:    res.writeHead(404);  
27:    res.write('404');  
28:    res.end();  
29:  };  
30:  server.listen(8080);  
31:  // socket.io, I choose you  
32:  var io = require('socket.io').listen(server);  
33:  // on a 'connection' event  
34:  io.sockets.on('connection', function(socket){  
35:   console.log("Connection " + socket.id + " accepted.");  
36:   // now that we have our connected 'socket' object, we can   
37:   // define its event handlers  
38:   socket.on('message', function(message){  
39:      console.log("Received message: " + message + " - from client " + socket.id);  
40:      socket.emit( 'message', 'Messaggio ricevuto');  
41:   });  
42:   socket.on('disconnect', function(){  
43:    console.log("Connection " + socket.id + " terminated.");  
44:   });  
45:  });

socketio_test.html

1:  <!doctype html>  
2:  <html>  
3:   <head>  
4:    <title>Socket.io Test</title>  
5:    <script src="/socket.io/socket.io.js"></script>  
6:    <script src="http://code.jquery.com/jquery-1.7.1.min.js"></script>  
7:   </head>  
8:   <body>  
9:    <script>  
10:    var socket;  
11:    var firstconnect = true;  
12:    function connect() {  
13:     if(firstconnect) {  
14:      socket = io.connect(null);  
15:      socket.on('message', function(data){ message(data); });  
16:      socket.on('connect', function(){ status_update("Connected to Server"); });  
17:      socket.on('disconnect', function(){ status_update("Disconnected from Server"); });  
18:      socket.on('reconnect', function(){ status_update("Reconnected to Server"); });  
19:      socket.on('reconnecting', function( nextRetry ){ status_update("Reconnecting in "   
20:       + nextRetry + " seconds"); });  
21:      socket.on('reconnect_failed', function(){ message("Reconnect Failed"); });  
22:      firstconnect = false;  
23:     }  
24:     else {  
25:      socket.socket.reconnect();  
26:     }  
27:    }  
28:    function disconnect() {  
29:     socket.disconnect();  
30:    }  
31:    function message(data) {  
32:      $.ajax({  
33:        dataType: 'jsonp',  
34:        data: 'message=' + data,  
35:        jsonp: 'jsonp_callback',  
36:        jsonpCallback: 'jsonpcallback',  
37:        url: 'http://<your_apache_root>/echo_service.php'  
38:      });      
39:    }  
40:    function jsonpcallback( rtndata ) {  
41:      $('#message').html( rtndata );  
42:    }  
43:    function status_update(txt){  
44:     document.getElementById('status').innerHTML = txt;  
45:    }  
46:    function esc(msg){  
47:     return msg.replace(/</g, '&lt;').replace(/>/g, '&gt;');  
48:    }  
49:    function send() {  
50:     socket.send("Hello Server!");    
51:    };      
52:    </script>  
53:    <h1>Socket.io Test</h1>  
54:    <div><p id="status">Waiting for input</p></div>  
55:    <div><p id="message"></p></div>   
56:    <button id="connect" onClick='connect()'/>Connect</button>  
57:    <button id="disconnect" onClick='disconnect()'>Disconnect</button>  
58:    <button id="send" onClick='send()'/>Send Message</button>  
59:   </body>  
60:  </html>

Software Open Source per le Camere di Commercio

2012-05-18T18:35:00.002+02:00

Da poche settimane ho ultimato un software per la gestione di contratti e appalti commissionato da una Camera di Commercio.
L'applicazione è scritta in PHP e sfrutta il framework Ampoliros e la libreria JQuery.
Visto che si tratta di un software destinato alla PA si è scelto di rilasciarlo con licenza GPL.
A causa della mia solita pigrizia per ora ho fatto solo alcuni screenshot (forse) seguirà un breve video dimostrativo.

Gateway Consorzio Triveneto per WP e-commerce

2012-04-27T11:57:00.001+02:00

Recentemente ho dovuto integrare il gateway di pagamento del Consorzio Triveneto nel plugin WP e-commerce, uno dei più noti plugin di commercio elettronico per Wordpress.
All'inizio pensavo di utilizzare l'ottima classe PgConsTriv di Davide Gullo, poi ho realizzato un'integrazione veramente minimale partendo dagli esempi forniti dal Consorzio e dalla documentazione di WP e-commerce.
E' puro spaghetti-code ma forse a qualcuno può tornare utile :)
Di seguito il codice del nuovo gateway da salvare nel folder /wp-content/plugins/wp-e-commerce/wpsc-merchants/ del vostro server.
Tutte le funzioni andrebbero raccolte in un unico file (compresi i callback di ritorno dal gateway), per intenderci $responseURL dovrebbe essere qualcosa del genere:

get_option('siteurl')."/?constriv=ok";

e quindi tutte le azioni verrebbero gestite dalla funzione gateway_constriv_gateway, purtroppo ho avuto qualche problema nella gestione degli indirizzi da parte del gateway e siccome sono pigro, non ho investigato più di tanto:
Alla fine ho utilizzato un work-around che segue passo-passo l'esempio fornito nella documentazione: ho usato i file receipt.php ed error.php per gestire la comunicazione con il gateway, questi poi fanno un redirect per completare la gestione dell'ordine e la visualizzazione di eventuali messaggi.
Nel file receipt.php dovreste implementare eventuali meccanismi di verifica della provenienza della transazione tramite i parametri udf*, io ho usato udf3 per trasportare l'id di sessione necessario a completare le operzioni sull'ordine.

constriv.merchant.php

1:  <?php  
2:  /**  
3:    * Gateway wp e-commerce per Consorzio Triveneto  
4:    * Marco Montesi 2012-04-26  
5:    * marco.montesi@gmail.com  
6:   *  
7:   * @package wp-e-comemrce  
8:   * @since 3.7.6  
9:   * @subpackage wpsc-merchants  
10:   */  
11:  $nzshpcrt_gateways[$num]['name'] = 'Consorzio Triveneto';  
12:  $nzshpcrt_gateways[$num]['internalname'] = 'constriv_gateway';  
13:  $nzshpcrt_gateways[$num]['function'] = 'gateway_constriv_gateway';  
14:  $nzshpcrt_gateways[$num]['form'] = "form_constriv_gateway";  
15:  $nzshpcrt_gateways[$num]['submit_function'] = "submit_constriv_gateway";  
16:  // admin form per memorizzare ID e password dell'account del cliente  
17:  function form_constriv_gateway()  
18:  {  
19:    $output ='<tr><td>';  
20:    $output.='<input name="constriv_tranportalid" type="text" value="'.get_option('constriv_tranportalid').'"/>';  
21:    $output.='TranPortalID';  
22:    $output.='<input name="constriv_password" type="text" value="'.get_option('constriv_password').'"/>';  
23:    $output.='Password';  
24:    $output .='</tr></td>';  
25:    return $output;  
26:  }  
27:  //  
28:  function submit_constriv_gateway()  
29:  {  
30:    if($_POST['constriv_tranportalid'] != null) {  
31:      update_option('constriv_tranportalid', $_POST['constriv_tranportalid']);  
32:    }  
33:    if($_POST['constriv_password'] != null) {  
34:      update_option('constriv_password', $_POST['constriv_password']);  
35:    }  
36:    return true;  
37:  }  
38:  // gateway   
39:  function gateway_constriv_gateway($seperator, $sessionid)  
40:  {  
41:    global $wpdb, $wpsc_cart;  
42:    //This grabs the purchase log id from the database  
43:    //that refers to the $sessionid  
44:    $purchase_log = $wpdb->get_row( "SELECT * FROM `".WPSC_TABLE_PURCHASE_LOGS."` WHERE `sessionid`= ".$sessionid." LIMIT 1", ARRAY_A) ;  
45:    // costruisco la stringa da passare al gateway per l'auth  
46:    $ID     = get_option('constriv_tranportalid');  
47:    $Password = get_option('constriv_password');  
48:    $Action   = "4";  
49:    $Amt    = number_format($wpsc_cart->total_price,2);  
50:    // sostituire con il proprio dominio  
51:    $ResponseURL = "<il_mio_dominio>/constriv/receipt.php";  
52:    $ErrorURL =  "<il_mio_dominio>/constriv/error.php";  
53:    $TrackId = "<il_mio_dominio>-".$purchase_log['id'];  
54:    $DataToSend ="id=$ID&password=$Password&action=$Action&amt=$Amt&currencycode=978&langid=ITA&responseURL= $ResponseURL&errorURL=$ErrorURL&trackid=$TrackId&udf1=AA&udf2=BB&udf3=$sessionid&udf4=DD&udf5=EE";   
55:    // ambiente di test, da sostituire con URL di produzione  
56:    $URL = "https://test4.constriv.com/cg301/servlet/PaymentInitHTTPServlet";  
57:    //Apro la connessione  
58:    $ch=curl_init($URL);   
59:    //Imposto gli headers HTTP  
60:    //imposto curl per protocollo https  
61:    curl_setopt($ch,CURLOPT_SSL_VERIFYPEER, FALSE);  
62:    curl_setopt($ch,CURLOPT_POST,1);  
63:    //Invio i dati  
64:    curl_setopt($ch,CURLOPT_POSTFIELDS,$DataToSend);  
65:    //imposta la variabile PHP   
66:    curl_setopt($ch,CURLOPT_RETURNTRANSFER, 1);   
67:    //Ricevo la risposta dal server  
68:    $varResponse=curl_exec($ch);   
69:    //chiudo la connessione   
70:    curl_close($ch);   
71:    if (substr($varResponse,0,7) == '!ERROR!') {  
72:      echo $varResponse;  
73:    } else {  
74:      //Separo il contenuto della stringa ricevuta (PaymentID:RedirectURL)  
75:      $varPosiz= strpos($varResponse, ':http');  
76:      $varPaymentId= substr($varResponse,0,$varPosiz);  
77:      $nc=strlen($varResponse);  
78:      $nc=($nc-17);  
79:      $varRedirectURL=substr($varResponse,$varPosiz+1);  
80:      //Creo l'URL di redirezione  
81:      $varRedirectURL ="$varRedirectURL?PaymentID=$varPaymentId";  
82:      //echo $varRedirectURL;  
83:      //Redirezione finale del browser sulla HPP  
84:      //echo $varRedirectURL;  
85:      echo "<meta http-equiv=\"refresh\" content=\"0;URL=$varRedirectURL\">";  
86:    }  
87:  }  
88:  function nzshpcrt_constriv_callback()  
89:  {  
90:   global $wpdb;  
91:   if( isset($_GET['constriv']) && ($_GET['constriv'] == 'transok')) {  
92:      $sessionid = $_REQUEST["udf3"];  
93:      $PayID=$_REQUEST["paymentid"];  
94:      $TransID=$_REQUEST["tranid"];  
95:      $ResCode=$_REQUEST["resultcode"];  
96:      $AutCode=$_REQUEST["auth"];  
97:      $PosDate=$_REQUEST["postdate"];  
98:      $TrckID=$_REQUEST["trackid"];  
99:      $Brand = $_REQUEST["cardtype"];  
100:      $Protocol = $_REQUEST["payinst"];  
101:      $Protection = $_REQUEST["liability"];  
102:      $HostResponseCode = $_REQUEST["responsecode"];  
103:      $Mistake = $_REQUEST["Error"];  
104:      $MistakeText = $_REQUEST["ErrorText"];  
105:      if( strlen(trim($AutCode)) and $ResCode == 'APPROVED' ) {  
106:        $sql = "UPDATE `".WPSC_TABLE_PURCHASE_LOGS."` SET `processed`= '3' WHERE `sessionid`=".$sessionid;  
107:        $wpdb->query($sql);  
108:        $transact_url = get_option('transact_url');  
109:        unset($_SESSION['WpscGatewayErrorMessage']);  
110:        echo '<script>document.location="'.$transact_url.'&sessionid='.$sessionid.'&status=ok";</script>';        
111:      } else {  
112:        $sql = "UPDATE `".WPSC_TABLE_PURCHASE_LOGS."` SET `processed`= '5' WHERE `sessionid`=".$sessionid;  
113:        $wpdb->query($sql);  
114:        $transact_url = get_option('transact_url');  
115:        $_SESSION['WpscGatewayErrorMessage'] = $Mistake.' '.$MistakeText;  
116:        echo '<script>document.location="'.$transact_url.'&sessionid='.$sessionid.'&status=ko";</script>';        
117:      }  
118:    }  
119:    if( isset($_GET['constriv']) && ($_GET['constriv'] == 'transko')) {  
120:      $sql = "UPDATE `".WPSC_TABLE_PURCHASE_LOGS."` SET `processed`= '5' WHERE `sessionid`=".$sessionid;  
121:      $wpdb->query($sql);  
122:      $transact_url = get_option('transact_url');  
123:      $_SESSION['WpscGatewayErrorMessage'] = $Mistake.' '.$MistakeText;  
124:      echo '<script>document.location="'.$transact_url.'&sessionid='.$sessionid.'";</script>';    
125:    }  
126:  }  
127:  //  
128:  add_action('init', 'nzshpcrt_constriv_callback');  
129:  ?>

receipt.php

1:  <?php   
2:  $PayID=$_POST["paymentid"];  
3:  $TransID=$_POST["tranid"];  
4:  $ResCode=$_POST["result"];  
5:  $AutCode=$_POST["auth"];  
6:  $PosDate=$_POST["postdate"];  
7:  $TrckID=$_POST["trackid"];  
8:  $UD1=$_POST["udf1"];  
9:  $UD2=$_POST["udf2"];  
10:  $UD3=$_POST["udf3"];  
11:  $UD4=$_POST["udf4"];  
12:  $UD5=$_POST["udf5"];  
13:  $Brand = $_POST["cardtype"];  
14:  $Protocol = $_POST["payinst"];  
15:  $Protection = $_POST["liability"];  
16:  $HostResponseCode = $_POST["responsecode"];  
17:  $Mistake = $_POST["Error"];  
18:  $MistakeText = $_POST["ErrorText"];  
19:  // Nell URL seguente inserire l'indirizzo corretto del proprio server  
20:  if( strlen(trim($AutCode)) and $ResCode == 'APPROVED' and $UD1=='AA' and $UD2 == 'BB' ) {  
21:    $ReceiptURL="REDIRECT=http://<mio_dominio>/?page_id=<id_carrello>&constriv=transok&PaymentID=".$PayID."&TransID=".$TransID."&TrackID=".$TrckID."&postdate=".$PosDate."&resultcode=".$ResCode."&auth=".$AutCode."&Error=".$Mistake."&ErrorText=".$MistakeText."&cardtype=".$Brand."&payinst=".$Protocol."&liability=".$Protection."&responsecode=".$HostResponseCode."&udf3=".$UD3;       
22:  } else {  
23:    $ReceiptURL="REDIRECT=http://<mio_dominio>/?page_id=<id_carrello>&constriv=transko&PaymentID=".$PayID."&TransID=".$TransID."&TrackID=".$TrckID."&postdate=".$PosDate."&resultcode=".$ResCode."&auth=".$AutCode."&Error=".$Mistake."&ErrorText=".$MistakeText."&cardtype=".$Brand."&payinst=".$Protocol."&liability=".$Protection."&responsecode=".$HostResponseCode."&udf3=".$UD3;       
24:  }  
25:  echo $ReceiptURL;   
26:  ?>

error.php

1:  <?php   
2:  $PayID=$_POST["paymentid"];  
3:  $TransID=$_POST["tranid"];  
4:  $ResCode=$_POST["result"];  
5:  $AutCode=$_POST["auth"];  
6:  $PosDate=$_POST["postdate"];  
7:  $TrckID=$_POST["trackid"];  
8:  $UD1=$_POST["udf1"];  
9:  $UD2=$_POST["udf2"];  
10:  $UD3=$_POST["udf3"];  
11:  $UD4=$_POST["udf4"];  
12:  $UD5=$_POST["udf5"];  
13:  $Brand = $_POST["cardtype"];  
14:  $Protocol = $_POST["payinst"];  
15:  $Protection = $_POST["liability"];  
16:  $HostResponseCode = $_POST["responsecode"];  
17:  $Mistake = $_POST["Error"];  
18:  $MistakeText = $_POST["ErrorText"];  
19:  $ReceiptURL="REDIRECT=http://<mio_dominio>/?page_id=<id_carrello>&constriv=transko&PaymentID=".$PayID."&TransID=".$TransID."&TrackID=".$TrckID."&TransID=".$TransID."&TrackID=".$TrckID."&postdate=".$PosDate."&resultcode=".$ResCode."&auth=".$AutCode."&Error=".$Mistake."&ErrorText=".$MistakeText."&cardtype=".$Brand."&payinst=".$Protocol."&liability=".$Protection."&responsecode=".$HostResponseCode."&udf3=".$UD3;       
20:  echo $ReceiptURL;   
21:  ?>

Gingerbread (Android 2.3) su Toshiba Folio

2011-12-01T17:30:00.001+01:00

Salve a tutti, qualche settimana fa mi hanno praticamente regalato un Toshiba Folio.
Toshiba ha prodotto questo bel tablet Tegra2 e ci ha messo su un Android 2.2 castrato del market e delle applicazioni Google.
La frustrazione di avere tra le mani un hardware ancora quasi al top con un software deprimente è stata tale che mi sono deciso a provare la via del modding.
La cosa non è stata tanto facile perché Toshiba, oltre ad aver fatto questa scelta a dir poco discutibile sul sistema installato, ha pensato bene di aggiornare il firmware in modo tale che non fosse possibile flashare ROM alternative :)
Ovviamente l'esemplare in mio possesso aveva il firmware aggiornato...
Comunque, per farla breve, alla fine sono riuscito ad installare Cyanogen 7.1, ovvero Android 2.3.7, e adesso il tablet è una bomba: tutte le Google Apps, Flash, Firefox, giochini 3D, etc etc

Di seguito riassumo i passi da fare se volete cimentarvi, e siccome sono un po' bastardo dentro non metto le istruzioni passo passo (troppa fatica) ma solo i link delle risorse ;)

Rootare il Folio;
di guide ce ne sono una marea;
Scaricare e flashare un firmware pre-aggiornamento
ho usato la recovery della FolioMod più o meno come dice qua http://forum.xda-developers.com/showthread.php?t=961826 ;
opzionale: flashare ClockWorkMod per Folio;
probabilmente non è necessario ma poi avrete molte più opzioni: http://www.arctablet.com/blog/featured/clockworkmod-recovery-v3-0-0-5-toshiba-folio100/
scaricare e flashare Cyanogen per Folio per update a 2.3.5;
avevo provato a mettere direttamente la 2.3.7 ma non riuscivo a flashare;
http://forum.xda-developers.com/showthread.php?t=933989&page=53
scaricare e flashare le Google Apps;ovviamente scegliete la versione per Cyanogen 7:
http://wiki.cyanogenmod.com/index.php?title=Latest_Version/Google_Apps
aggiornare a 2.3.7;
addirittura forse adesso c'è qualcosa di più aggiornato, andate a spulciare qua:
http://forum.xda-developers.com/showthread.php?t=933989
enjoy.

Widget jQuery su Ampoliros

2011-08-25T17:46:00.001+02:00

Un piccolo esempio dell'utilizzo della libreria jQuery e di alcuni widget jQuery UI.
La piattaforma di sviluppo è Ampoliros, la libreria AJAX utilizzata è XAJAX.

PS ho fatto lo screencast per provare SOM: consigliato!

Feed stream pubblico Google+ (unofficial)

2011-07-17T12:22:00.009+02:00

Ancora Google non ha pubblicato le API di G+ ma gli smanettoni si sono dati da fare da subito.
Ad esempio è possibile ottenere in formato JSON lo stream dei post pubblici di un utente.
Dopo aver visto questo articolo (grazie Gian Angelo) ho provato subito con qualche riga di PHP.
Ci sono già progetti promettenti in rete, ma io mi sono limitato allo stretto indispensabile.
Accertatevi di avere attivato il supporto SSL in PHP e sostituite $googleplus_id con l'id utente che vi interessa (basta guardare l'url del profilo):

  $googleplus_id = '110373656360084352107';

$url = 'https://plus.google.com/_/stream/getactivities/'.$googleplus_id.'/?sp=%5B1%2C2%2C%22'.$googleplus_id.'%22%2Cnull%2Cnull%2Cnull%2Cnull%2C%22social.google.com%22%2C%5B%5D%5D';

per recuperare i dati basta usare file_get_contents (a patto che in php.ini abbiate settato allow_url_fopen):

$output = file_get_contents( $url );

La stringa JSON ottenuta va "ripulita" come indicato nell'articolo citato:



 $json = substr( $output, 4 );

$json = str_replace( '[,', '["",', $json );

while( strpos( $json, ',,' ) ) $json = str_replace( ',,', ',"",', $json );

Finalmente abbiamo una stringa che possiamo dare in pasto a json_decode per ottenere un array contenete i nostri post pubblici su Google+:



 $feedArray = json_decode($json);

foreach( $feedArray[1][0] as $currPost ) {

echo 'Autore: '.$currPost[3].'<br>';

echo 'Titolo: '.$currPost[4].'<br>';

foreach( $currPost[11] as $postLinks ) {

echo ' -> Titolo link: '.$postLinks[3].'<br>';

echo ' -> Descr. link: '.$postLinks[21].'<br>';

echo ' -> Url link: '.$postLinks[24][1].'<br>';

}

echo '<br>';

}

That's all!

Nota
Se non volete abilitare allow_url_fopen potete provare con cURL, sostituendo la chiamata a file_get_contents con questo codice:

 $ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $url );

curl_setopt($ch, CURLOPT_HEADER, 0);

curl_setopt ($ch, CURLOPT_RETURNTRANSFER, 1) ;

$output = curl_exec($ch);

curl_close($ch);

Smartphone e drag&drop

2011-07-13T15:48:00.000+02:00

Al giorno d'oggi se le tue applicazioni non supportano in qualche modo i dispositivi mobili non sei nessuno!
Mi ritengo fortunato perché da circa 10 anni sviluppo quasi esclusivamente in ambiente web, utilizzando tecnologie standard, quindi le applicazioni sono direttamente visualizzabili su qualunque aggeggio abbia un browser degno di questo nome.
Ci sono però alcune situazioni che richiedono uno sforzo ulteriore.
E' il caso di tutti i dispositivi dotati di touch screen e delle funzionalità drag&drop.
Su iPhone, iPad o sul vostro smartphone Android l'applicazione viene visualizzata correttamente ma se provate a trascinare... il browser scrolla o esegue un pan nella pagina.
Ad esempio in Kroneos MP gli utenti si possono scambiare dei post-it, ovvero semplici messaggi che rimangono "appiccicati" al loro desktop virtuale piuttosto che al monitor reale ;)
Questi oggetti anche graficamente riprendono l'aspetto di un post-it, il classico quadrato di colori fosforescenti.
Gli utenti possono spostare i posti-it sullo schermo ed ancorarli in posizioni comode.

Con il mouse il tutto avviene in maniera molto naturale.
Ma su un touch screen è semplicemente impossibile.
Dei ragazzi italiani hanno scritto una bella classe Javascript che implementa dei div "draggabili" su dispositivi touch: Drag Drop Library for Ipad & Iphone (funziona anche con Android).
L'ho provata, ma su pagine particolarmente cariche ho avuto problemi di prestazioni.
Per ora l'unica soluzione è stato il classico uovo di Colombo, ovvero ho dovuto rinunciare al drag&drop :P
Al posto dei foglietti svolazzanti i messaggi li ho impilati in un accordion jQuery UI (nel caso lo user agent corrisponda ad un iQualcosa o ad un Droide).
Qualcuno ha avuto un'idea più brillante?

Una bella sorpresa: jQuery Mobile

2011-07-08T11:13:00.001+02:00

Volete realizzare la versione "mobile" del vostro sito?
Volete che l'aspetto sia il più possibile simile ad una app nativa?
Volete gradevoli effetti grafici?
Volete tempi di sviluppo rapidi e semplice integrazione con altri tools?
Ok, jQuery Mobile fa per voi.
Poche ore di lavoro per leggere i tutorial, integrare la libreria nel cms ed ecco il risultato: http://www.efficienza-professionale.it/mobile/index.php
Tutto in alpha stage, ma il primo contatto è stato ottimo.

Gruppi su GMail con Zend GData

2011-07-06T16:13:00.002+02:00

Da qualche tempo ho realizzato un'integrazione tra l'anagrafica di Kroneos MP ed i contatti di GMail.

Ho utilizzato Zend Gdata visto che avevo già ottenuto buoni risultati nell'integrazione del calendario con GCalendar.

Per la gestione dei contatti però non ho trovato documentazione ed esempi come nel caso degli eventi.

La fonte migliore che ho trovato in rete è questa.

Nell'articolo non viene trattata la gestione dei gruppi, per cui condivido quello che ho concluso spulciando direttamente le API del protocollo di Google.

Supponendo che abbiate a disposizione un oggetto DOMDocument come descritto nell'articolo:

$doc = new DOMDocument();

$doc->formatOutput = true;

$entry = $doc->createElement('atom:entry');

$entry->setAttributeNS('http://www.w3.org/2000/xmlns/' ,'xmlns:atom', 'http://www.w3.org/2005/Atom');

$entry->setAttributeNS('http://www.w3.org/2000/xmlns/' ,'xmlns:gd', 'http://schemas.google.com/g/2005');

$entry->setAttributeNS('http://www.w3.org/2000/xmlns/' ,'xmlns:gContact', 'http://schemas.google.com/contact/2008');

$doc->appendChild($entry);

per associare il contatto ad un gruppo basta aggiungere questo codice:

$gMembership = $doc->createElement('gContact:groupMembershipInfo');

$gMembership->setAttribute('href', $groupUrl );

$gMembership->setAttribute('deleted', 'false' );

$entry->appendChild($gMembership);

La variabile $groupUrl contiene il riferimento al gruppo che ci interessa.

Se il gruppo non esiste occorre crearlo con una procedura del genere:

$doc  = new DOMDocument();

$doc->formatOutput = true;

$entry = $doc->createElement('atom:entry');

$entry->setAttributeNS('http://www.w3.org/2000/xmlns/' , 'xmlns:atom', 'http://www.w3.org/2005/Atom');

$entry->setAttributeNS('http://www.w3.org/2000/xmlns/' , 'xmlns:gd', 'http://schemas.google.com/g/2005');

$doc->appendChild($entry);

// add category

$cat = $doc->createElement('atom:category');

$cat->setAttribute('scheme', 'http://schemas.google.com/g/2005#kind' );

$cat->setAttribute('term', 'http://schemas.google.com/contact/2008#group' );

$entry->appendChild($cat);

// add group name element

$name = $doc->createElement('atom:title', );

$name->setAttribute('type', 'text' );

$entry->appendChild($name);

//

$extProp = $doc->createElement('gd:extendedProperty');

$extProp->setAttribute('name', );

$entry->appendChild($extProp);

$info = $doc->createElement('info', );

$extProp->appendChild($info);

//

$entryResult = $gdata->insertEntry($doc->saveXML(), 'http://www.google.com/m8/feeds/groups/default/full' );

Il riferimento al gruppo si ottiene con

$groupUrl = $entryResult->id;

Primo post

2011-03-06T15:18:00.000+01:00

Yet another personal blog on the Internet!