p = subprocess.Popen(["/bin/bash", "/usr/bin/resize.x", id], stdout = subprocess.PIPE)
p.stdout.read()

resize.x contient le code suivant:

#!/bin/bash
filename=$1
convert -resize "500x500" /var/www/data/$filename.png /var/www/data/$filename"_s.png"
convert -resize "300x300" /var/www/data/$filename.png /var/www/data/$filename"_m.png"
convert -resize "75x75" /var/www/data/$filename.png /var/www/data/$filename"_t.png"
convert -resize "48x48" /var/www/data/$filename.png /var/www/data/$filename"_e.png"

On a donc nos 5 fichiers (originale + 4 versions de taille différente) à uploader vers Amazon S3.

On a besoin de créer un bucket qui va contenir nos fichiers. Celà peut-être fait à partir de la console de configuration sur Amazon.

Pour la suite, on va utiliser la librairie python boto qui va nous faciliter la tâche.

On a besoin de définir les variables suivantes dans settings.py dans notre projet Django.

BUCKET_NAME = 'bucket_name'
AWS_ACCESS_KEY_ID = ...
AWS_SECRET_ACCESS_KEY = ...

Upload vers S3

Voici le code pour uploader nos photos (plus les versions de taille différente):

def push_picture_to_s3(id):
  try:
    import boto
    from boto.s3.key import Key
    # demande à boto de n'imprimer que les messages critical
    logging.getLogger('boto').setLevel(logging.CRITICAL)
    bucket_name = settings.BUCKET_NAME
    # on se connecte au bucket
    conn = boto.connect_s3(settings.AWS_ACCESS_KEY_ID,
                    settings.AWS_SECRET_ACCESS_KEY)
    bucket = conn.get_bucket(bucket_name)
    # on s'occupe des 5 fichiers: original + 4 versions de taille différente
    suffixes = ['', '_e', '_m', '_s', '_t']
    for s in suffixes:
      key = 'dish_%s%s.png' % (id, s)
      fn = '/var/www/data/%s%s%s' % (id, s, ext)
      # on crée une clé pour ce fichier
      k = Key(bucket)
      k.key = key
      k.set_contents_from_filename(fn)
      # on indique ce fichier comme étant public pour pouvoir y accéder
      # en utilisant un lien comme http://s3.amazonaws.com/bucket_name/key
      k.make_public()
      # on efface le fichier localement
      os.remove(fn)
  except:
    ...

Download à partir de S3

Comme on l’a vu, on peut accéder au fichier sur Amazon S3 en utilisant le lien: http://s3.amazonaws.com/bucket_name/key. On peut également y accéder en utilisant la librairie boto pour downloader les fichiers. J’utilise cette méthode pour créer une copie journalière sur mon PC.

Voici le script Python pour faire cela:

import boto
import sys, os
from boto.s3.key import Key

LOCAL_PATH = '/backup/s3/'
AWS_ACCESS_KEY_ID = '...'
AWS_SECRET_ACCESS_KEY = '...'

bucket_name = 'bucket_name'
# on se connecte au bucket
conn = boto.connect_s3(AWS_ACCESS_KEY_ID,
                AWS_SECRET_ACCESS_KEY)
bucket = conn.get_bucket(bucket_name)
# on parcoure la liste des fichiers
bucket_list = bucket.list()
for l in bucket_list:
  keyString = str(l.key)
  # on vérifie si le fichier existe localement, si non, on le télécharge
  if not os.path.exists(LOCAL_PATH+keyString):
    l.get_contents_to_filename(LOCAL_PATH+keyString)

Côté client

On a besoin d’un formulaire pour que l’utilisateur puisse uploader un fichier.

Nous avons ajouté 2 inputs, la première ‘X-Progress-ID’ est l’identifiant de l’upload pour que l’on puisse supporter plusieurs uploads simultanément.

On a l’input ‘id’ qui représente l’identifiant du plat dans notre cas.

On va utiliser Ajax pour la requête POST pour pouvoir l’intégrer dans une interface web moderne avec une barre de progression. Pour cela, on va utiliser le plugin jQuery Form.

La méthode ajaxSubmit() va s’occuper de tout pour nous

On génère une string aléatoire pour l’ID de l’upload et on l’attribue à l’input ‘X-Progress-ID’.
On a besoin de spécifier l’URL pour l’upload et 2 functions: 1 qui est appelée avant l’upload et une après.

$('#X-Progress-ID').val('random string');
var options = {
  dataType: 'xml',
  url: '/upload?X-Progress-ID='+$('#X-Progress-ID').val(),
  beforeSubmit: showRequest,
  success: showResponse
}
$('#form_upload').ajaxSubmit(options);

Quand l’utilisateur clique sur le bouton pour démarrer l’upload, on doit présenter une barre de progression. Pour cela, on utilise le code JS suivant pour ajouter une barre de progression au formulaire. La méthode progressBar() fait partie de jQuery progress bar plugin.

On a aussi besoin d’une fonction pour récupérer la progression de l’upload à partir du serveur pour mettre à jour la barre de progression régulierement.

Pour faire cela, on utilise setInterval() afin d’émettre une requête GET pour récupérer la valeur de la progression au format JSON. On passe l’identifiant de l’upload dans la requête. L’upload est terminée quand la valeur null est renvoyée.

function startProgressBarUpdate(upload_id) {
  $("#uploadprogressbar").fadeIn();
  if(g_progress_intv != 0)
    clearInterval(g_progress_intv);
  g_progress_intv = setInterval(function() {
    $.getJSON("/web_modules/process.py?request=get_upload_progress&X-Progress-ID="
+ upload_id, function(data) {
      if (data == null) {
        $("#uploadprogressbar").progressBar(100);
        clearInterval(g_progress_intv);
        g_progress_intv = 0;
        return;
      }
      var percentage = Math.floor(100 * parseInt(data.uploaded) / parseInt(data.length));
      $("#uploadprogressbar").progressBar(percentage);
    });
  }, 5000);
}

Coté serveur

On a besoin d’une méthode dans views.py pour recevoir les fichiers. On lit chaque fichier bloc par bloc pour éviter d’utiliser trop de RAM.

def upload(request):
  id = request.POST['id']
  path = '/var/www/pictures/%s' % id
  f = request.FILES['picture']
  destination = open(path, 'wb+')
  for chunk in f.chunks():
    destination.write(chunk)
  destination.close()

Comment le serveur suit la progression de l’upload ? On doit utiliser un file handler spécial. On utilise UploadProgressCachedHandler. On a juste besoin de la classe, pas la méthode pour la vue car on va s’en occuper nous même. Vous pouvez ajouter cette classe dans un fichier s’appelant uploadprogresscachedhandler.py dans votre projet Django.

Pour activer cet handler, on ajoute les lignes suivantes dans settings.py.

from django.conf import global_settings
FILE_UPLOAD_HANDLERS = (uploadprogresscachedhandler.UploadProgressCachedHandler', ) \
+ global_settings.FILE_UPLOAD_HANDLERS

On a aussi besoin d’activer un système de cache. On va utiliser memcached. On ajoute la ligne suivante dans settings.py.

CACHE_BACKEND = 'memcached://127.0.0.1:11211/'

Assurez vous d’avoir memcached et les bindings python installés sur votre serveur.

On a besoin d’ajouter une méthode dans views.py pour retourner la progression de l’upload au client quand il le demande. La valeur de la progression se trouve dans la cache spécifiée par la clé remoteaddress_uploadid

def get_upload_progress(request):
  from django.utils import simplejson
  cache_key = "%s_%s" % (request.META['REMOTE_ADDR'], request.GET['X-Progress-ID'])
  data = cache.get(cache_key)
  return HttpResponse(simplejson.dumps(data))

Voila, c’est tout pour l’instant. N’hesitez pas à ajouter des commentaires pour continuer la discussion.

Si vous avez aimé cet article, ça serait cool d’aller sur mon site Gourmious pour découvrir et partager vos plats préférés au resto.

Le package va être responsable pour:

• Installer l’application
• Configurer le serveur web (dans notre cas: Lighttpd + fastcgi)
• Script init.d pour démarrer/arrêter le serveur Django

On va utiliser une template debconf pour demander 1 question à l’utilisateur. Cela va rendre le package plus dynamique..

On présume que l’application Django se trouve dans /usr/share/djangoapp . C’est là où se trouve settings.py, manage.py, views.py etc…

Tout d’abord, on crée un dossier debian et on copie le dossier de l’application Django dedans.

mkdir ./debian
mkdir -p ./debian/usr/share/
cp -r /usr/share/djangoapp ./debian/usr/share/

On a également besoin de créer un dossier DEBIAN dans debian/

mkdir ./debian/DEBIAN

Fichiers dans DEBIAN

Ce dossier doit contenir les fichiers suivants:

• control
• config
• conffiles
• templates
• postinst
• postrm
• preinst
• prerm

control

C’est le fichier le plus important dans un package Debian. Ce fichier défini le package et ses dépendances. Il contient dans notre cas le texte suivant:

Package: djangoapp
Version: 0.1-1
Section: devel
Priority: optional
Architecture: all
Depends: python, python-django, python-flup, debconf, lighttpd
Maintainer: Laurent Luce
Description: short description
 long description

Le paramètre « depends » est une liste de packages dont depends notre package.

config

config est un script demandant des questions à l’utilisateur avant que le package soit installé. On demande une seule question dans notre exemple:

#!/bin/sh -e

# Source debconf library.
. /usr/share/debconf/confmodule

# votre nom ?
db_input critical djangoapp/username || true
db_go

On a besoin d’inclure le module debconf. Notre question est de type ‘critical’.

Mais où est la définition de notre question ? Elle est défini dans le fichier templates

templates

Template: djangoapp/username
Type: string
Description: Username:
Ce package nécessite votre nom

conffiles
Ce fichier contient les fichiers de configuration généralement localisés dans /etc . Nous ajoutons le fichier de lancement de Django.

/etc/init.d/django

preinst
Ce script est executé avant l’installation du package.

#!/bin/bash
set -e

# stop le serveur Django
if [ -f /etc/init.d/django ]
then
  invoke-rc.d django stop
fi

postinst
Ce script est executé après l’installation du package.

#!/bin/sh
set -e

# Source debconf library.
. /usr/share/debconf/confmodule

db_get djangoapp/username
username="$RET"
# utiliser le nom de l'utilisateur comme bon vous semble

# enregistrer Django
update-rc.d django defaults 90 >/dev/null
# démarrer Django
invoke-rc.d django start

db_stop

postrm
Ce script est executé après que le package soit désinstallé.

#!/bin/bash
set -e

if [ "$1" = "purge" -a -e /usr/share/debconf/confmodule ]; then
    # Source debconf library.
    . /usr/share/debconf/confmodule
    # Supprimer mes changements dans la base de données
    db_purge
fi

if [ "$1" = "remove" ]; then

# Source debconf library.
. /usr/share/debconf/confmodule

# Supprimer le script de lancement de Django
update-rc.d -f django remove

# Supprimer mes changements dans la base de données
db_purge
fi

prerm
Ce script est exécuté avant la désinstallation du package

#!/bin/bash
set -e

# stop django server
invoke-rc.d django stop

Configuration du serveur web

On a besoin de modifier le fichier de configuration de lighttpd: lighttpd.conf:

mod_fastcgi doit être ajouté à la liste des modules du serveur.

le serveur Django écoute sur le port 3033:

fastcgi.server = (
  "/djangoapp.fcgi" => (
    "main" => (
      # Use host / port instead of socket for TCP fastcgi
      "host" => "127.0.0.1",
      "port" => 3033,
      "check-local" => "disable",
  ))
)

Script Django init.d

C’est le moment d’ajouter notre script de lancement pour Django:

#! /bin/sh
### BEGIN INIT INFO
# Provides:          FastCGI servers for Django
# Required-Start:    networking
# Required-Stop:     networking
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Django FastCGI
#

DJANGO_SITE="djangoapp"
SITE_PATH=/var/www
RUNFILES_PATH=$SITES_PATH/tmp
HOST=127.0.0.1
PORT_START=3033
RUN_AS=www-data

set -e

PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
DESC="Django FastCGI"
NAME=$0
SCRIPTNAME=/etc/init.d/$NAME

#
#       Function that starts the daemon/service.
#
d_start()
{
    # Starting all Django FastCGI processes
    echo -n ", $DJANGO_SITE"
    if [ -f $RUNFILES_PATH/$DJANGO_SITE.pid ]; then
        echo -n " already running"
    else
       start-stop-daemon --start --quiet \
                       --pidfile $RUNFILES_PATH/$DJANGO_SITE.pid \
                       --chuid $RUN_AS --exec /usr/bin/env -- python \
                       $SITE_PATH/$DJANGO_SITE/manage.py runfcgi \
                       host=$HOST port=$PORT \
                       pidfile=$RUNFILES_PATH/$DJANGO_SITE.pid
    fi
}

#
#       Function that stops the daemon/service.
#
d_stop() {
    # Killing all Django FastCGI processes running
    echo -n ", $DJANGO_SITE"
    start-stop-daemon --stop --quiet --pidfile $RUNFILES_PATH/$SITE.pid \
                          || echo -n " not running"
    if [ -f $RUNFILES_PATH/$DJANGO_SITE.pid ]; then
        rm $RUNFILES_PATH/$DJANGO_SITE.pid
    fi
}

ACTION="$1"
case "$ACTION" in
    start)
        echo -n "Starting $DESC: $NAME"
        d_start
        echo "."
        ;;

    stop)
        echo -n "Stopping $DESC: $NAME"
        d_stop
        echo "."
        ;;

    restart|force-reload)
        echo -n "Restarting $DESC: $NAME"
        d_stop
        sleep 1
        d_start
        echo "."
        ;;

    *)
        echo "Usage: $NAME {start|stop|restart|force-reload}" >&2
        exit 3
        ;;
esac

exit 0

Le script doit être placé dans ./debian/etc/init.d/

On a besoin de créer un lien de /var/www/djangoapp vers /usr/share/djangoapp

changelog, changelog.Debian et copyright

Ces fichiers sont nécessaires pour notre package:

changelog

djangoapp (0.1-1) unstable; urgency=low

  * Initial release.
    + Initial package

 -- Laurent Luce Fri, 01 Jan 2010 00:00:00 +0000

Dans notre cas, changelog.Debian contient la même chose que changelog.

copyright

DjangoApp

Copyright: bla bla

2010-01-01

The home page of xxx is at: 

http://www.xxx.com

Copyright xxx 2010

On doit placer ces fichiers proprement:

mkdir -p ./debian/usr/share/doc/djangoapp
cp changelog changelog.Debian copyright ./debian/usr/share/doc/djangoapp/
gzip --best ./debian/usr/share/doc/djangoapp/changelog
gzip --best ./debian/usr/share/doc/djangoapp/changelog.Debian

Construction du package

On doit régler les permissions:

find ./debian -type d | xargs chmod 755

On construit le package et on le vérifie de cette manière:

fakeroot dpkg-deb --build debian
mv debian.deb DjangoApp_0.1-1_all.deb
lintian DjangoApp_0.1-1_all.deb

Notre package est prêt !!!

Si vous avez aimé cet article, ca serait cool d’aller sur mon site Gourmious pour découvrir et partager vos plats préférés au resto.

Côté client

Un module très sympa à utiliser est poster. Ca aide à faire des requêtes POST en utilisant le codage multipart/form-data. Le module va nous permettre également de faire du streaming.

Tout d’abord, on crée un cookie:

cj = cookielib.CookieJar()

Ensuite, on a besoin d’importer quelques fonctions du module poster:

from poster.encode import multipart_encode
from poster.streaminghttp import StreamingHTTPHandler, StreamingHTTPRedirectHandler, StreamingHTTPSHandler

On crée un opener en utilisant les fonctions de streaming du module poster:

handlers = [StreamingHTTPHandler, StreamingHTTPRedirectHandler, StreamingHTTPSHandler]
opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj), *handlers)
urllib2.install_opener(opener)

On pourrait utiliser la fonction register_openers() du module poster mais elle ne supporte l’authentification donc on utilise les fonctions internes.

On lit la liste des fichiers du dossier ‘/data’ et on les envoie au serveur.

params = {}
dir = u'/data/'
for f in os.listdir(dir):
  params[f] = open(dir+f)
data, headers = multipart_encode(params)
url = 'https://test/upload.py'
req = urllib2.Request(url, data, headers)
result = urllib2.urlopen(req)

Côté serveur

On ne veut pas saturer la mémoire vive donc on va lire les données par paquets.

Les fichiers reçus sont dans request.FILES qui est un dictionnaire d’objets de type UploadedFile

Si la taille du fichier est supérieur à 2.5MB (cette limite peut être modifiée dans votre settings.py), il sera divisé en plusieurs paquets pour ne pas utiliser trop de RAM.

On ajoute le code suivant dans views.py pour recevoir les fichiers.

for key, file in request.FILES.items():
  path = '/data/'+ file.name
  dest = open(path.encode('utf-8'), 'wb+')
  if file.multiple_chunks:
    for c in file.chunks():
      dest.write(c)
    else:
      dest.write(file.read())
    dest.close()

Voila, tous les fichiers envoyés sont maintenant sur le serveur et cela d’une manière optimisée.

N’hésitez pas à commenter cet article.

Si vous avez aimé cet article, ca serait cool d’aller sur mon site Gourmious pour découvrir et partager vos plats préférés au resto.

Je voulais aussi que tous les utilisateurs de Gourmious aient un compte Gourmious et donc j’ai décidé de ne pas autoriser l’authentification si l’utilisateur n’a pas de compte Gourmious.

J’ai décidé de supporter les 3 scénarios suivants:

1- L’utilisateur a un compte Django, il s’identifie en utilisant son compte Facebook, je joins son compte Django avec son compte Facebook. Cela a besoin d’être effectué qu’une seule fois.

2- L’utilisateur n’a pas de compte Django et essaie de s’identifier avec son compte Facebook. Je lui demande tout d’abord de créer un compte Django puis je joins son compte Django avec son compte Facebook.

3- L’utilisateur s’identifie avec son compte Django.

Facebook oauth est plus facile à intégrer que l’ancien Facebook Connect. J’étais très content de migrer ma plate forme vers cette nouvelle méthode.

On présume que vous avez déjà un serveur avec votre app Django et que vous avez créer une appli Facebook.

On va utiliser l’appli Django django_facebook_oauth pour faciliter la tâche. vérifiez que vous avez simplejson d’installé avant de continuer.

Facebook utilise le protocole OAuth 2.0 pour l’authentification et l’autorisation. Je vous conseille de lire cet article avant de continuer:
Facebook authentication

Récuperez le code de l’appli Django Facebook oauth:

git clone http://github.com/dickeytk/django_facebook_oauth.git

Copiez le dossier django_facebook_oauth dans votre dossier appli Django et renommez le ‘facebook’.

On présume que votre dossier appli Django s’appelle ‘apps’.

Django settings.py

On a besoin de faire les changements suivants:

• Ajoutez ‘apps.facebook.backend.FacebookBackend’ à AUTHENTICATION_BACKENDS.
• Ajoutez ‘apps.facebook’ à INSTALLED_APPS
• Ajoutez votre ID Facebook: API_ID = xxxx.
• Ajoutez votre clé secrète Facebook: APP_SECRET = xxxx.

Django urls.py

Ajoutez la ligne suivante à urlpatterns:
(r », include(‘apps.facebook.urls’)),

Changements dans la base de données

On a besoin de créer une table pour associer l’ID Django d’un utilisateur avec son ID Facebook et pour sauvegarder le token de la session Facebook. Vous pouvez utiliser syncdb ou vous pouvez créer la table manuellement.

CREATE TABLE `facebook_facebookuser` (
  `id` int(11) NOT NULL auto_increment,
  `user_id` int(11) NOT NULL,
  `facebook_id` varchar(150) NOT NULL,
  `access_token` varchar(150) default NULL,
  PRIMARY KEY  (`id`),
  UNIQUE KEY `user_id` (`user_id`),
  UNIQUE KEY `facebook_id` (`facebook_id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8

Le flux de l’authentification Facebook

1- L’utilisateur cliques sur le bouton Facebook
2- La vue ‘authenticate’ de l’appli Django Facebook est appelée
3- L’URL Graph API de Facebook est appelée avec l’ID de votre appli Facebook, redirect uri = /authenticate, scope = ‘publish_stream’ pour demander l’autorisation de poster sur le compte Facebook de l’utilisateur.
4- La vue ‘authenticate’ de l’appli Django Facebook est appelé avec un code qui est le token pour la session Facebook.
5- L’authentification passe par la fonction authenticate() de l’appli Django Facebook.
6- Si l’utilisateur existe dans la table facebook_facebookuser, on l’identifie puis on renvoie vers la page d’accueil. Si l’utilisateur n’est pas dans la table, on lui demande de s’identifier avec son identifiant Django pour qu’on puisse joindre son compte Django à son compte Facebook.

Appli Django Facebook views.py

J’ai modifié views.py pour utiliser mon formulaire d’authentification pour joindre le compte Django de l’utilisateur à son compte Facebook au lieu d’utiliser le formulaire inclus dans l’appli Django Facebook.

Après que le token soit renvoyé et si l’utilisateur n’est pas dans la table Facebook, on ajoute un paramètre dans la session Django pour indiquer à la template que le formulaire d’authentification doit être affiché pour pouvoir joindre le compte Django au compte Facebook.

if user != None:
  login(request, user)
  return HttpResponseRedirect('/')
else:
  # lignes ajoutées
  request.session['ask_to_login_facebook'] = '1'
  return HttpResponseRedirect('/')
  #return HttpResponseRedirect('/register/')

Quand l’utilisateur s’identifie avec son identifiant Django, on ajoute une nouvelle entrée dans la table Facebook. On a besoin de faire cela qu’une fois. Après cela, l’utilisateur pourra s’identifié directement en utilisant le bouton Facebook.

Voici le code ajouté dans mon appli Django views.py:

# check credentials
user = authenticate(username=username, password=password)
if user is not None:
  if user.is_active:
    if 'fb_id' in request.session:
      fb_user = FacebookUser(user = user,
        facebook_id = request.session['fb_id'],
        access_token = request.session['fb_token'])
      fb_user.save()
      del request.session['fb_id']
      del request.session['fb_token']
      login(request, user)
      status = 0
    else:
      status = 1
  else:
    status = 1
    msg = _('Invalid password')

Appli Django Facebook backend.py

Juste une petite modification dans ce fichier pour ajouter dans la session le token Facebook pour pouvoir l’utiliser dans views.py de notre appli Django.

try:
  fb_user = FacebookUser.objects.get(facebook_id = str(profile["id"]))
except FacebookUser.DoesNotExist:
  request.session['fb_id'] = profile['id']
  # ligne ajoutée
  request.session['fb_token'] = access_token
  return None
fb_user.access_token = access_token
fb_user.save()

Template de l’appli Django

On ajoute la forme suivante à la template de notre appli Django pour afficher le bouton Facebook.

J’ai également ajouté une option ‘Poster sur Facebook’ sur le formulaire pour poster un commentaire sur un plat. Cela donne le choix à l’utilisateur de poster ou non le commentaire sur son compte Facebook en même temps.

Poster un message sur le compte Facebook de l’utilisateur

J’avais l’habitude d’utiliser le SDK Javascript de Facebook pour poster les messages. Maintenant, j’utilise le SDK Python de Facebook du côté serveur.

Ajoutez le fichier facebook.py (http://github.com/facebook/python-sdk/blob/master/src/facebook.py) dans le dossier de l’appli Django Facebook et renommez le ‘facebook_sdk.py’ .

On appelle la fonction put_wall_post() pour poster un message sur le compte Facebook de l’utilisateur.

Voila le code que j’utilise dans views.py de mon appli Django pour préparer les paramètres nécessaires à la fonction put_wall_post() .

def post_to_facebook(request):
  try:
    fb_user = FacebookUser.objects.get(user = request.user)
    # GraphAPI est la classe dans facebook_sdp.py
    graph = GraphAPI(fb_user.access_token)
    attachment = {}
    message = 'test message'
    caption = 'test caption'
    attachment['caption'] = caption
    attachment['name'] = 'test name'
    attachment['link'] = 'link_to_picture'
    attachment['description'] = 'test description'
    graph.put_wall_post(message, attachment)
    return 0
  except:
    logging.debug('Facebook post failed')

Voila, n’hesitez pas à ajouter des commentaires ou à m’envoyer des questions.

Si vous avez aimé cet article, ça serait cool d’aller sur mon site Gourmious pour découvrir et partager vos plats préférés au resto.