A la recherche du cumulo-codus !

Présentation du projet

2009-02-06T00:06:00.000-08:00

Hier, nous avons présenté notre projet devant le jury de soutenance composé de :

Steve Sfartz, Architecte Senior, Microsoft France
Lucien Martos, Responsable Génie Logiciel, EPSI Montpellier
Sylvie Malézieux, Directrice Régionale, EPSI.

Les retours que nous avons obtenus sont très positifs et la présentation a eu beaucoup de succès.
Les démonstrations ont permis d'illustrer le fonctionnement et la stabilité de l'architecture.
Voici le diaporama que nous avons présenté ce jeudi : Diaporama

Nous rappelons que l'ensemble du projet est disponible sur Sourceforge et que chacun a la possibilité de télécharger librement le code pour l'étudier ou le déployer.

Nous préparons actuellement un guide de déploiement expliquant les installations nécessaires au bon fonctionnement de la solution. Il sera bientôt disponible sur ce blog.

En attendant, nous restons disponibles pour toute question sur le projet ou l'interopérabilité.

Microsoft Techdays 2009 : il y aura du cloud computing

2009-02-03T23:49:00.000-08:00

Comme vous le savez certainement, le salon des Techdays de Microsoft se tiendra du 10 au 12 février au Palais des Congrès de Paris.

Ce sera l'occasion pour Microsoft de détailler et d'expliquer le fonctionnement de la plateforme de développement Azure.
Sur le TechBlog de Microsoft, vous pouvez voir une interview de Thomas Lucchini (Microsoft France) qui annonce les différentes sessions qui toucheront au cloud computing. Pour notre part, nous assisterons au moins à celle de Steve Sfartz ainsi que celle de Ronny Kwon le mardi 10 février, car ils devraient parler de Silverlight Streaming, de Azure et ... de notre projet !

Si vous vous rendez aux Techdays pour cette édition 2009, profitez-en pour venir nous rencontrer au stand EPSI.

Faire part de naissance.

2009-02-03T14:28:00.000-08:00

En ce beau jour que fut le 03 Février 2009, la magie de la vie a permis à

http://voditup.cloudapp.net/

qui pèse 10Mo et mesure plusieurs milliers de lignes de codes de voir enfin le jour sous le regard attendri de ses parents.

Il faudra bien sûr du temps et la patience pour qu'il grandisse et atteigne un développement adulte et mature.

Trève de plaisanterie, l'équipe clouditup est heureuse de vous présenter la version béta de notre site de VOD (Utilisant des technologies Microsoft telles que Silverlight Streaming Platform, SQL Data Services, Azure queue et table...)

Maxime, Léo , Sébastien et Mathieu.

- Consultez les nouveautés

- Consultez des fiches de film

- Consultez vos locations

- Et surtout, visionnez vos films !

Windows Azure : Comment déployer un projet volumineux ?

2009-02-02T15:29:00.000-08:00

Lorsque vous développez un projet Cloud WebRole pour Azure qui est volumineux, il se peut que vous soyez confrontés à l'erreur suivante lorsque vous essaierez de publier ("Publish") votre solution :

Error 41 The "CSPack" task failed
unexpectedly.System.IO.IsolatedStorage.IsolatedStorageException: Unable to
determine the identity of domain. at
System.IO.IsolatedStorage.IsolatedStorage._GetAccountingInfo(Evidence evidence,
Type evidenceType, IsolatedStorageScope fAssmDomApp, Object&
oNormalized) at
System.IO.IsolatedStorage.IsolatedStorage.GetAccountingInfo(Evidence evidence,
Type evidenceType, IsolatedStorageScope fAssmDomApp, String& typeName,
String& instanceName) at
etc...

Cette erreur indique que Visual Studio ne peut pas "packager" le projet.

La solution réside dans un utilitaire fournit avec Azure SDK. Ouvrez l'invité de commande du SDK, et utilisez "cspack" de la manière suivante :

- positionnez vous dans le dossier racine de votre solution (celui proposant un dossier pour le WebRole et un dossier pour la solution).
- tapez la commande suivante (avec vos valeurs bien entendu) :

cspack DossierDeLaSolution\ServiceDefinition.csdef
/role:WebRole;DossierDuWebRole /out:NomDuPackage.cspkg

Le package est publié manuellement, et vous pouvez maintenant l'uploader sur votre compte Azure afin d'effectuer vos tests.

Silverlight Streaming : Problème lors de l'upload depuis l'interface

2009-01-31T17:32:00.001-08:00

Il semblerait que Silverlight Streaming connaisse un problème lors de l'upload d'une vidéo depuis l'interface web (http://silverlight.live.com/).

Après renseignement, cette erreur n'est visiblement pas fréquente. Néanmoins, je vous l'expose :

Pour le développement de notre projet, nous avons mis quelques vidéos sur la plateforme Silverlight Streaming afin d'effectuer nos tests.

Nous avons uploadé une vidéo d'environ 50 Mo. Une fois sur le serveur, elle affiche plus de 5 Go. Soit environ 100 fois plus.
Un algorithme de compression ou autre ne justifie pas cette différence, puisqu'aucun algorithme de streaming ne multiplie la taille du fichier par 100. Un autre point étrange est que lorsque l'on consulte cette vidéo, nous devrions théoriquement mettre 5000 secondes (à hauteur de 1 Mo / seconde en download) pour pouvoir la télécharger entièrement, et donc la consulter jusqu'à la fin. Mais en l'occurrence, la consultation est très rapide et la lecture ne se bloque à aucun moment pour charger la suite de la vidéo.

(Précisons que cet évènement est apparu à chaque upload de vidéo que nous avons fait par l'interface web de Silverlight Streaming)

Une image étant plus probante que de longues palabres, je vous laisse juger de cette "bizarerie" :

Service Azure de gestion des URL temporaires pour Silverlight Streaming

2009-01-30T15:40:00.001-08:00

Le service de gestion des URL temporaires pour Silverlight Streaming est maintenant terminé.

Il permet de récupérer une URL temporaire (le temps est paramétrable. Il est pour l'instant initialisé à 400 secondes) donnant accès à une vidéo copiée. L'intérêt est d'empécher la lecture de la vidéo une fois le temps de location expiré.

Pour ce faire, on utilise un projet Cloud contenant un WebRole et un WorkerRole. Le schéma suivant montre les appels effectuaient par notre service vers d'autres services.

WebRole

Il expose un service REST contenant l'opération doCopy(string upc). Cette opération va lancer une recherche sur SQL Server Data Services (accès en SOAP) de toutes les locations concernant la vidéo en question. Notre nouvelle vidéo portera comme nom la concaténation de l'upc et du dernier identifiant de location de cette vidéo + 1.
Ainsi, si la vidéo dont l'upc est 123 est louée pour la première fois, le nom du FileSet dans Silverlight Streaming sera 123_0. Pour la seconde location de cette vidéo, ce sera 123_1. Ainsi de suite. Ainsi, on assure que tout nos FileSets aient des noms différents.

Une fois cet identifiant trouvé, nous effectuons l'ajout en base de données de notre nouvelle location. Ensuite, nous lançons la copie de la vidéo d'origine (toujours cachée à l'utilisateur par sécurité) vers le nouveau FileSet. Cette copie s'effectue en REST (voir lab précédent).

Enfin, le service retourne l'URL de la vidéo accessible à l'utilisateur (donc "http" et pas "https").

Notre service de copie est ici terminé.

WorkerRole

Le WorkerRole est désigné pour un traitement constant, isolé du reste du système. En l'occurence, il s'agit de l'évaluation de validité de nos locations.
Le WorkerRole possède donc une référence vers le service SOAP de SQL Server Data Services. La chose déroutante dans l'utilisation que l'on en fait est que l'on ne l'instancie pas. On possède juste cette référence comme un point de sortie vers SSDS. Cela, dans le but d'éviter de dupliquer le code. Pour ce faire on intègre aussi une référence vers notre WebRole, afin de bénéficier des classes de gestion de notre base de données et de Silverlight Streaming. Si l'on ne rajoute pas notre référence de SSDS dans le WorkerRole (en imaginant qu'on bénéficiera de celle du WebRole), alors le Proxy ne parvient pas à récupérer les informations nécessaires à son instanciation.

Au niveau de la vérification de validité, nous récupérons toutes nos locations, chaque minute. Nous vérifions celles qui sont encore valides (dont le champs "duree_valid" > 0). Nous décrémentons 60 (le nombre de secondes expirées) ou mettons ce champs à 0 (si le champs <>
Au final, ce service manipule SQL Server Data Services en SOAP, Silverlight Streaming en REST, et offre une opération publiée en REST.
L'ensemble est un peu complexe, mais tout à fait fonctionnel.

Vous pouvez retrouver les sources au sein du projet disponible sur Sourceforge.

SQL Data Services

2009-01-25T06:29:00.000-08:00

A travers ce lab, vous allez pouvoir utiliser une base de données dans les nuages (SDS) et récupérer les données pour les afficher dans votre page web.

Dans SDS :

Tout d'abord, commençons par créer votre base de données.
Connectez vous à l'adresse suivante : lien pour administrer vodre sds en ligne. Login et mot de passes sont ceux de votre solution Azure.

A savoir 3 notions essentielles dans SDS :
- Authority : il représente le nom de votre base de données
- Container : il représente une table
- Entity : C'est une ligne que l'on peut retrouver dans tout SGBD comprenant divers attributs. Une chose essentielles dans SDS vient du fait que dans chaque Container, on peut inserer différentes entity, j'entends pas là que chaque entity peut avoir des attributs différents.

Sélectionnez votre "authority" et ajouter lui un container.
Dans notre exemple, nous allons créer un container "video"

Dans ce container video, nous allons lui ajouter uen entity :
-titre (string) : "mon titre"
-url (string) : "monURL"
-description (string) : "maDescription"
-format (string) : "monFormat"
-duree (decimal) : "maDuree"

Dans notre Web Site :
1) Créer un projet "web site" sous Visual Studio
2) Modifiez le fichier "web.config" et ajouter les lignes suivantes, en donnant le nom de votre "authority", et login et mot de passe de votre solution

3) Créer un client SOAP dans une classe SOAPMethod.cs

4) Créer votre classe "video"

5) Ajouter la méthode pour récupérer vos vidéos

6) Récupérer vos vidéos du coté behind et les afficher dans un listview

7) Afficher le résultat dans votre page .aspx

Web Service sur Azure + accès REST à Silverlight Streaming

2009-01-22T14:17:00.000-08:00

Je vais vous montrer à travers ce lab comment construire un service pour Azure permettant d'effectuer des copies sur SLS (Silverlight Streaming Service). Nous attaquons Silverlight Streaming à l'aide de la méthode COPY du protocole REST. Le COPY va effectuer la copie du Fileset spécifié (sur la plateforme Silverlight Streaming, une vidéo est nommée "video.wmv" et est identifiée à l'aide du nom de son FileSet).
Tout d'abord, créons un projet "Web Cloud Service" sous Visual Studio 9 (contenant toutes les libs nécessaires, indiquées dans un lab précédent).

WebRole

Le WebRole est une application web contenant une page default.aspx.
Ajoutons un nouvel élément à ce projet : "Add -> New Item". Choisissez WCF Service.

Edition : Après avoir rencontré des problèmes pour interroger le service hébergé sur Azure et exposé en SOAP, il semble que la seule manière de publier ce service dans le "Cloud" est de l'exposer en REST. Les indications suivantes ont donc été modifiées afin de le rendre fonctionnel sur la plateforme de Microsoft.

Merci à Ronny Kwon ( bloginthecloud ) et Florient Gutierrez ( projet Kumoe ) pour leur précieuse aide !

Modifions le "endpoint" décrit dans le fichier Web.config. Vous devez changer le champs "binding". A la place de "wsHttpBinding", nous utilisons "webHttpBinding".

Dans l'interface générée (nommée ici ICopieVideo.cs), ajoutez le prototype de votre opération ainsi que les instructions permettant l'accès en REST :

[OperationContract()]
[WebGet(UriTemplate = "doCopy/{upc}/", RequestFormat= WebMessageFormat.Xml, ResponseFormat= WebMessageFormat.Xml, BodyStyle= WebMessageBodyStyle.Bare)]
string doCopy(string upc);

Il faut maintenant ajouter une référence vers System.ServiceModel.Web (clique droit sur la solution -> Add reference). Ajouter cette référence dans l'interface :

using System.ServiceModel.Web;

Enfin, il faut indiquer une factory dans CopieVideo.svc (clique droit -> View Markup) :

Factory="System.ServiceModel.Activation.WebServiceHostFactory"

Maintenant, implémentons notre interface dans CopieVideo.svc.cs. Nous aurons besoin d'autres méthodes. Par exemple getAuth() nous permet d'authentifier notre connexion à SLS. Voici à quoi elle ressemble (ainsi que la déclaration de nos variables globales) :

Une fois les crédentials créés, nous pouvons effectuer notre requête REST vers Silverlight Streaming Service. Pour cela, implémentons la méthode doCopy(string upc) :

A noter : il semblerait qu'il ne soit pas possible d'effectuer une copie d'un fileset avec un filesetName ayant déjà existé (si le fileset est issu d'un upload et d'un delete depuis l'interface d'administration web). Le headers["Destination"] doit donc contenir une adresse unique à chaque requête dans le cas où nos ajouts se font depuis l'interface web. Il faut donc le gérer en fonction de vos données (dans le cas de notre projet, avec les SQL Data Services lorsqu'ils seront liés à ce service de copie).

Notre service REST est prêt.

Consommation de test (Pour accéder au service exposé en local en SOAP)

(Exemple réalisé avant les dernières modifications : vous pouvez l'utiliser pour vos tests vers un service SOAP et non REST)

Créez un projet Application Console dans votre solution. Ajoutez une référence de service. Cliquez sur Discover. Là, l'environnement détècte les services de votre solution. Sélectionnez donc le service CopieVideo.svc .

Maintenant, implémentons le code de notre application :

Console.WriteLine("Upc à copier :");
string upc = Console.ReadLine();
var client = new ServiceCopieLocal.CopieVideoClient();
Console.WriteLine("résultat : " + client.doCopy(upc));
Console.ReadLine();

Exécutez cette application. Renseignez le nom du Fileset à copier. Le service effectue le traitement et vous renvoie la réponse :

Publication du service REST

Maintenant que notre solution Web Cloud Service contenant le WCF service est prête, nous pouvons la publier. Pour cela, faîtes un clique droit sur le projet -> "Publish". Cette opération nous crée deux fichiers dans le répertoire "/bin/publish/".

Package : *.cspkg
Configuration : *.cscfg

La page https://lx.azure.microsoft.com/Cloud/Provisioning/Default.aspx devrait alors s'ouvrir. Créez un nouveau projet, et choisissez "Hosted Project" (nécessite une code d'invitation). Suivez les instructions et uploadez vos deux fichiers sur Azure.

Une fois hébergé, transitez votre projet depuis le mode Staging vers le mode Production (afin de lier votre projet à une URL fixe et unique).
L'installation du service est terminée. Vous devriez pouvoir y accéder à l'adresse de votre projet azure.

Pour tester votre service REST, vous pouvez contacter l'URL de votre service avec les paramètres nécessaires. Par exemple, pour ce projet :

Le service nous renvoie le XML contenant l'URL de la vidéo copiée sur Silverlight Streaming.

Le code de ce lab est bien entendu disponible sur Sourceforge.

Utiliser l'API Silverlight Streaming avec RestLet

2009-01-10T02:08:00.000-08:00

Silverlight Streaming (SLS pour Silverlight Streaming Service) est un service offert par Microsoft, permettant de diffuser des vidéos et des applications Silverlight 2 sur Internet.
On peut déposer ses fichiers sur le serveur de SLS :

manuellement, par l'interface web proposée par Microsoft,
logiciellement, en utilisant l'API basée sur REST et documentée ici

Dans le cadre de notre solution de vidéo à la demande, nous souhaitons utiliser SLS pour le stockage et la diffusion des vidéos qui seront disponibles sur le site. L'alimentation de se catalogue de vidéo est réalisée par l'ensemble des vidéo clubs partenaires, qui possèdent un logiciel d'administration commun utilisant des technologies Java.

Notre but est donc d'utiliser l'API de Silverlight Streaming Service dans ce logiciel d'administration en Java, pour déposer automatiquement les nouvelles vidéos sur le serveur SLS de notre site de VOD.

Pour y parvenir nous utiliserons le framework RestLet, pour gérer ce type d'architecture dans notre logiciel Java.

Préparation du projet
Nous utilisons NetBeans pour ce lab mais n'importe quel IDE Java fonctionnerait aussi bien ici.

Créer tout d'abord un projet Java standard ou une librairie de classes Java en fonction de votre besoin.
Téléchargez le framework RestLet et ajoutez ses librairies au projet.

Initialisation des paramètres de connection
Plusieurs paramètres doivent être réglés avant d'initialiser une communication vers une architecture REST au moyen de RestLet :

Le type de protocole utilisé (ici HTTPS)
L'URI du service à contacter
Les identifiants, éventuellement nécessaires auprès du service contacté

Voici donc les paramètres que nous avons utilisé ici :

private final static String SILVERLIGHT_STREAMING_SERVICE_ROOT = "https://silverlight.services.live.com/";
private final static String SILVERLIGHT_STREAMING_ID = "87996";
private static String SILVERLIGHT_STREAMING_ACCESS_KEY;
private Client m_RestletClient;

Nous initialisons tout d'abord le protocole de communication :

m_RestletClient = new Client(Protocol.HTTPS);

Puis nous lisons les paramètres d'identification dans un fichier séparé :

private void readCredentialsFromPropertiesFile() throws IOException {
Properties SLSProperties = new Properties();
FileInputStream propertiesFile = new FileInputStream("../Ressources/credentials.txt");
SLSProperties.load(propertiesFile);
propertiesFile.close();

SILVERLIGHT_STREAMING_ACCESS_KEY = SLSProperties.getProperty("SLS_Access_Key");
}

Les paramètres étants réglés, nous allons pouvoir commencer à envoyer des requêtes à notre serveur SLS.

Création du "file set"
SLS peut recevoir à la fois des applications Silverlight 2 et des vidéos, c'est pourquoi la notion de file set a été choisie. Un file set est un répertoire sur notre compte SLS, pouvant contenir tous les fichiers d'une application Silverlight 2 ou une vidéo à diffuser.

Pour ajouter notre vidéo nous allons tout d'abord créer un répertoire vide (notre file set) et ensuite lui ajouter la vidéo.

Création du file set :

private void createFileSetForNewVideo() {
String fileSetName = "Nom_de_ma_video";
String serviceUri = SILVERLIGHT_STREAMING_SERVICE_ROOT + "/" + SILVERLIGHT_STREAMING_ID + "/" + fileSetName;
Request request = new Request(Method.MKCOL, serviceUri);

loadCredentialsForRequest(request);

Response response = m_RestletClient.handle(request);
}

Apres avoir choisi un nom pour le répertoire, on définit l'URI du service et on utilise la méthode d'envoi MKCOL (abréviation de Make Collection) pour créer un nouveau fileset.

L'appel loadCredentialsForRequest(request) va permettre d'ajouter les information d'identifications de lutilisateur auprès du serveur. Voici son contenu :

private void loadCredentialsForRequest(Request request) {
ChallengeScheme scheme = ChallengeScheme.HTTP_BASIC;
ChallengeResponse authentication = new ChallengeResponse(scheme,
SILVERLIGHT_STREAMING_ID, SILVERLIGHT_STREAMING_ACCESS_KEY);
request.setChallengeResponse(authentication);
}

Après avoir ajouté ces informations, on va lancer la requete en l'associant à l'objet client. La réponse pourra être récupérée pour vérifier que tout s'est bien déroulé.

Envoi du fichier vidéo
Enfin, nous envoyons le fichier vidéo dans le répertoire nouvellement créé.

La méthode est très proche de la précédente puisque on ne change que la méthode d'envoi qui devient du PUT et qu'on ajoute le fichier vidéo lui-même à la requête.
L'ajout du fichier à la requête se passe de cette façon :

FileRepresentation fileRepresentation = new FileRepresentation(m_UploadedFile, MediaType.VIDEO_WMV, 0);
EncodeRepresentation encodedFileRep = new EncodeRepresentation(Encoding.ALL, fileRepresentation);
request.setEntity(encodedFileRep);

Ces requêtes peuvent durer un certain temps (surtout l'envoi du fichier vidéo) donc n'oubliez pas d'utiliser un Thread séparé pour effectuer ces appels d'entrées/sorties.

Le résultat :

La vidéo est bien disponible et visible dans l'interface web de votre compte Silverlight Streaming Service.

L'ensemble du code est disponible sur SourceForge à l'adresse :
http://clouditup.svn.sourceforge.net/viewvc/clouditup/Projet/Backoffice%20Java/SilverlightStreamingHandlerLibrary/

La prochaine étape consistera à notifier notre site de VOD, ainsi que ceux de nos partenaires, de la disponibilité de cette vidéo.

Interopérabilité entre équipes

2009-01-06T08:54:00.000-08:00

L'un des avantages de l'interopérabilité entre les technologies est de faciliter les échanges entre les partenaires, encore faut-il s'entendre sur le contenu de chaque message échangé.

En effet, si l'interopérabilité nous garanti que l'on peut envoyer et recevoir des messages avec des technologies différentes, il nous faut pouvoir traiter le contenu du message pour que celui-ci présente un intérêt. Ce principe donne lieu à la publication de documentations, chez tous les acteurs offrant des web services, permettant de d'envoyer des messages compréhensibles et de pouvoir interpréter les réponses.

Dans le cadre de notre projet, nous devons gérer une solution de partenariat avec d'autres sites de VOD (Blog in the cloud et Projet Kumoe). L'idée est que chaque magasin de possédant des vidéos va les proposer aux sites de VOD.

Cette proposition se fera sous la forme d'une description de la vidéo et d'un tarif de location envoyés sous forme d'un message asynchrone aux partenaires. Les partenaires auront une file de message à traiter et déciderons alors s'il souhaitent récupérer le fichier vidéo dans leur plateforme de streaming, au prix proposé.

L'enjeu est maintenant de s'entendre sur les informations contenues dans ce message et sur le nom des balises XML le décrivant.

Voici notre première proposition

, envoyée aux responsables des autres sites de VOD :

La quantité d'information est minimale et nous permettrait de développer la solution rapidement dans un premier temps. On pourrait bien évidemment ajouter toutes les informations habituelles relatives à un film (auteur, réalisateur, acteurs, etc.) mais notre but est principalement lié à l'interopérabilité et non à l'exhaustivité.

Lorsque les débats entres responsables de sites de VOD seront terminés, nous afficherons la documentation finale de ces messages dans ce blog.

Lab 4 : To be or not to be...

2009-01-02T14:27:00.000-08:00

Ce lab est consacré à la mise en place d'une authentification live ID pour des applications web .Net et Java.
Je m'efforcerai de décrire les points importants nécessaires à la mise en place de cette identification.

A noter : vous pouvez télécharger les SDK et les exemples pour Windows Live ID à l'adresse suivante : http://dev.live.com/liveid.

Live ID pour .Net

Tout d'abord, il faut paramétrer le fichier Web.xml de votre application. Celui ci doit contenir les informations d'identification de votre application auprès des services Live. Pour enregistrer votre application, rendez-vous sur le portail de Azure https://lx.azure.microsoft.com/Cloud/Provisioning/Default.aspx, en utilisant vos propres identifiants live ID. Vous saisirez alors le nom de votre application, une description de celle-ci, ainsi que l'adresse de retour vers laquelle Windows Live renverra le Token (dans mes essais, il s'agit de http://localhost:1805/webauth-handler.aspx ).
Voici à quoi ressemble le fichier Web.xml :

wll_appid correspond à l'identifiant de votre application (donné lors de l'enregistrement). wll_secret correspond à la clé secrète de votre application. Il ne faut donc pas que ce fichier soit accessible depuis l'extérieur.

Dans votre fichier default.aspx, ajouter les lignes suivantes :

Ces lignes affichent un lien permettant de se connecter ou se déconnecter de Windows Live, en contactant l'URL indiqué ci-dessous :
src="http://login.live.com/controls/WebAuth.htm?appid=<%=AppId%>&style=font-size%3A+10pt%3B+font-family%3A+verdana%3B+background%3A+white%3B"

Comment récupère-t-on le Token (jeton d'identification) ?
A l'aide de la classe WindowsLiveLogin qui reçoit le token depuis la page d'identification Live ID et l'enregistre dans le cache du navigateur à l'aide d'un Cookie. Live ID renvoie ce token à l'aide d'une requête HTTP, à l'aide du protocole REST.
Voyons de plus près dans le fichier de retour webauth-handler.aspx.cs :

WindowsLiveLogin.User user = wll.ProcessLogin(req.Form);
HttpCookie loginCookie = new HttpCookie(LoginCookie);

La classe WindowsLiveLogin effectue le traitement du login :

public User ProcessLogin(NameValueCollection query)

{

string action = query["action"];

string token = query["stoken"];

string context = query["appctx"];

if (context != null)

{

context = HttpUtility.UrlDecode(context);

}

return ProcessToken(token, context);
}

La méthode ProcessToken nous permet d'obtenir une version lisible du token, en le parsant et en découpant les champs qui nous sont utiles.

Enfin, pour identifier automatiquement un utilisateur déjà authentifié auprès de live ID, il suffit de rechercher dans ses Cookies la présence de notre token (dans le fichier Default.aspx.cs) :

HttpRequest req = HttpContext.Current.Request;

HttpCookie loginCookie = req.Cookies[LoginCookie];

if (loginCookie != null)

{

string token = loginCookie.Value;
if (!string.IsNullOrEmpty(token))

{

WindowsLiveLogin.User user = wll.ProcessToken(token);

if (user != null)

{

UserId = user.Id;

}

}

}

Il est donc très facile de mettre en place une authentification Live ID pour notre application web .Net, d'autant plus que la documentation disponible sur internet est très précise.

Live ID pour Java

De la même manière que nous avons enregistré notre application .Net auprès des services Windows Live, il faut enregistrer cette application et configurer le fichier Application-Key.xml :

Ceci est le fichier fourni dans l'exemple disponible avec le SDK.

Dans le fichier index.jsp, il faut initialisé le module Windows Live Login. Comme pour la version .Net, cette classe s'occupera de traiter la requête en provenance du site Live ID, afin d'obtenir notre jeton :

// Initialisation de WLL avec KEYFILE correspondant au fichier Application-Key.xml
// (configuré dans settings.jsp)
WindowsLiveLogin wll = new WindowsLiveLogin(KEYFILE);
wll.setDebug(DEBUG);

// Nous récupérons le champs AppID depuis Application-Key.xml
String appId = wll.getAppId();
String userid = null;
String username = null;

// vérification de la présence du token dans le cache. S'il est présent, chargement du User ID
String token = (String) session.getAttribute(TOKEN);

if (token != null) {
WindowsLiveLogin.User user = wll.processToken(token);

if (user != null) {
userid = user.getId();
}

}

// Ici, nous pouvons rechercher dans notre base de données le nom d'utilisateur
// correspondant au UserID trouvé précédemment

}

L'accès au lien de connexion ou de déconnexion de live ID se fait par le même procédé qu'en .Net (étant donné qu'il s'agit de balises HTML).

Résultat

Dans les deux cas, nous obtenons la page suivante :

Dans la première fenêtre, on nous invite à nous connecter au travers d'un lien généré par Windows Live (l'url contenu dans l'iframe).

Lorsqu'on se connecte, nous recevons un token nous permettant de connaître l'identifiant de l'utilisateur. Le texte contenu dans l'iframe affiche alors "sign out".

Conclusion :

L'authentification Live ID apparaît donc comme un moyen efficace pour identifier nos utilisateurs sans pour autant mettre en place un système d'authentification qui nous est propre. De plus, cela accroît l'interopérabilité avec d'autres services, en fournissant ce moyen d'identification unique aux services Live, à nos services, et bien d'autres...

Vous pouvez télécharger les sources de ce lab ainsi que de la version application lourde .Net ICI.

Lab 3 : Je suis absent, veuillez laisser un message.

2009-01-02T06:58:00.000-08:00

Dans le cadre de notre projet nous souhaitons que des partenaires puissent nous communiquer leurs nouveautés afin de pouvoir les rendre disponibles à la consultation sur notre site de vod.

Pour être accessible même lorsque notre serveur est hors ligne, nous avons décidé de mettre en place une file de messages. Pour ce faire, nous avons plusieurs solutions :

Une solution payante de type Amazon Simple Queue Service.
Une solution implémentant les .Net Services (à travers le service bus).
Une solution reposant sur Azure.

Bien que nous ayons choisi la troisième solution dans notre application, nous avions au préalable fait un petit projet de file de messages pour prendre en main les .Net Services. C'est ce projet que je vais vous présenter dans ce lab.

Figure 1 : En haut, client qui push deux messages et la réception dans la file en bas.

Environnement de développement :

Temps nécessaire : 30 minutes.

Note : Cette application vise à présenter l'exposition d'un service sur le service bus, en ce sens elle est simpliste et le code présenté a juste un objectif pédagogique.

Pré-requis : Il est nécessaire de posséder un compte Microsoft .Net Services (actuellement l'activation des comptes se fait par codes d'invitation : informations disponibles ici).

La première étape de notre lab sera de créer une file de messages (on utilisera la classe Queue de .Net). Comme l'on souhaite avoir une seule file de messages on utilisera le pattern Singleton.

On écrira donc une classe contenant une méthode qui crée une instance uniquement s'il n'en existe pas encore. Sinon celle-ci renverra une référence vers l'objet qui existe déjà.

private static QueueMessage instance = null;
private Queue notreQueue;

//constructeur privé pour qu'on ne puisse pas instancier la classe autrement que par la méthode createQueue()
private QueueMessage()
{
notreQueue = new System.Collections.Queue();
}

public static QueueMessage createQueue()
{
//creation d'une nouvelle instance s'il n'en existe pas déjà une.
if (instance == null)
return instance = new QueueMessage();
else
return instance;
}

On va ensuite créer une interface qui exposera une méthode push pour pousser un message dans la file.

[ServiceContract(Name = "IQueueContract", Namespace = "http://ServiceQueue.IQueueContrat")]
public interface IQueueContrat
{
[OperationContract]
string Push(string message);
}

Notre service implémentera cette classe :

[ServiceBehavior(Name = "QueueService", Namespace = "https://ServiceQueue.QueueService")]
public class QueueService : IQueueContrat
{
private QueueMessage notreQueue;

public string Push(string message)
{
notreQueue = QueueMessage.createQueue();
notreQueue.Queue.Enqueue(message);
Console.WriteLine("Message ajoutée a la file FIFO: {0}", message);
Console.WriteLine("La file contient maintenant {0} messages non consommés",notreQueue.Queue.Count);
return message;
}
}

On va ensuite éditer notre app.config :

On utilisera le binding netTcpRelayBinding et le mode de connexion au service bus sera celui par défaut (Relay).

On peut enfin exposer notre service sur le service bus :

//Identification via la solution et le mot de passe
string solutionName = "Votre_Solution";
Console.Write("Entrez votre mot de passe : ");
string solutionPassword = ReadPassword();

// création du point de terminaison de notre service Queue
Uri address = new Uri(String.Format("sb://{0}/services/{1}/QueueService/EndPoint", ServiceBusEnvironment.DefaultRelayHostName, solutionName));

//Définition des crédentials, le client devra s'authentifier avec un username/password
var userNamePasswordServiceBusCredential = new TransportClientEndpointBehavior();

userNamePasswordServiceBusCredential.CredentialType = TransportClientCredentialType.UserNamePassword;

userNamePasswordServiceBusCredential.Credentials.UserName.UserName = solutionName;
userNamePasswordServiceBusCredential.Credentials.UserName.Password = solutionPassword;

//création du service host
var host = new ServiceHost(typeof(QueueService), address);

//on applique les crédentials a chaque endpoint
foreach (ServiceEndpoint endpoint in host.Description.Endpoints)
{
endpoint.Behaviors.Add(userNamePasswordServiceBusCredential);
}

//ouverture du service
host.Open();

Console.WriteLine("Service address: " + address);
Console.WriteLine("Press [Enter] to exit");
Console.ReadLine();

host.Close();

Notre service est maintenant disponible sur le service bus :

Code complet disponible sur sourceforge : ICI

Le prochain lab concernera la solution que nous avons retenu, à savoir créer une file de message reposant sur Azure.

A bientôt !

Afficher un flux Rss Sur Silverlight

2008-12-28T09:09:00.000-08:00

Dans le but de maintenir à jour notre application silverlight, notre choix s'est porté sur l'utilisation de flux RSS. En générant un flux à partir de chaque serveur back office, il est beaucoup plus facile d'afficher les dernières vidéos ajoutées sur chacun d'eux.

RSS est un format d'échange de données, défini en XML, dont la dernière version est la 2.0.
Le fichier XML a la forme suivante :

Créons maintenant un projet silverlight, dans lequel nous allons récupérer toutes nos vidéos contenues dans le fichier XML.

1) Installer SilverLight Tools pour Visual Studio .NET 2008 SP1 (disponible ici)

2) Dans Visual Studio 2008 :

File -> New -> Project
Csharp -> Silverlight -> SilverlightApplication
Appelez le "ExempleRSS"
Sélectionnez “Add a new ASP.NET" et garder les options par défaut

3) Ajoutez les références System.ServiceModel.Syndication et System.Windows.Controls à votre projet en faisant un clic droit sur votre projet, add reference.

4) Dans votre page "Page.xaml.cs", ajouter le code suivant au constructeur :

WebClient rssclient = new WebClient();
rssclient.OpenReadCompleted += new OpenReadCompletedEventHandler(rssclient_OpenReadCompleted);

//URL du flux rss
Uri UriFeed = new Uri("http://feeds.feedburner.com/VCMontpellier");
rssclient.OpenReadAsync(UriFeed);

L'objet WebClient permet de communiquer avec le flux RSS. L'appel à la fonction "lire" se fera en "asynchrone", en attendant la fin de son execution avant d'effectuer l'affichage des données.

5) Pour réaliser cet affichage, commençons par créer notre datagrid. Double cliquez sur "Page.xaml", et en utilisant la toolbox présente sur la gauche de la fenêtre, sélectionnez "datagrid" et placez le entre les balise.

6) Lecture des informations du fichier XML.

void rssclient_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e)
{
XmlReader rssreader = XmlReader.Create(e.Result);
SyndicationFeed feed = SyndicationFeed.Load(rssreader);

this.feedContent.ItemsSource = feed.Items;
}

L'objet XMLReader nous permet de lire le fichier XML et l'objet Syndication est quand à lui utilisé pour récupérer toutes les informations lues.
Ensuite, il ne nous reste plus qu'à transmettre les données au datagrid.

7)Pour afficher ces informations, nous avons jusqu'à présent simplement déclarer notre datagrid. Il ne nous reste plus qu'à l'implémenter afin de voir nos données affichées.

A l'intérieur des balises , nous rajoutons :

<data:DataGridTextColumn Header="Titre" Binding="{Binding Path=Title.Text}"/>

<data:DataGridTextColumn Header="Date de sortie" Binding="{Binding Path=PublishDate}"/>

<data:DataGridTextColumn Header="Résumé" Binding="{Binding Path=Summary.Text}"/>

8) Résultat :

Conclusion :
Comme vous avez pu le constater, en quelques lignes de code, il devient très rapide de récupérer et d'afficher le contenu d'un flux RSS. Il ne vous reste plus qu'à installer Expression Blend SP1s (disponible ici) et de mettre en forme votre affichage.

Lab 2 : Quand JavaFX se confie à Amazon

2008-12-16T14:57:00.000-08:00

Au travers de ce lab nous allons voir comment utiliser les WebServices gratuits de Amazon pour récupérer des informations de DVD à partir de son code barre (numéro UPC), en Java et JavaFX.

Pourquoi ?

Il est vrai que nous avions déjà démontré comment utiliser les WebServices de Amazon dans notre projet (voir le ticket Amazone, belle amazone) mais puisque nous cherchons à promouvoir l'interopérabilité des technologies, nous n'avons pas pu résister à tester la compatibilité du SDK de JavaFX qui vient d'être annoncé.

Les outils :

Java 1.5+
JavaFX 1.0 SDK
NetBeans 6.5 avec le module JavaFX d'installé

Le principe :
JavaFX est un langage de script permettant de développer des application internet riches (RIA), capable d'appeler du code Java standard de façon transparente pour l'utilisateur. Partant de cette idée, nous utiliserons :

JavaFX pour réaliser l'interface et les animations de notre application
Java standard pour consommer les WebServices d'Amazon

Le code :
La première chose à faire est de créer un projet de type Java standard et de lui ajouter une référence de WebService :

Dans le code Java nous allons créer une classe nommée WebServiceControler et possédant un objet décrivant le point d'entrée du service de Amazon :

public class WebServiceControler {
private AWSECommerceServicePortType m_AWSServicePort;

public WebServiceControler() {
m_AWSServicePort = new AWSECommerceService().getAWSECommerceServicePort();
}
}

Dans le code ci-dessus, AWSECommerceService() permet d'obtenir la référence au WebService d'Amazon que nous avons crée auparavant. Nous pouvons ensuite lui demander la connexion au endpoint (service port), en récupérant la liste des opérations et messages gérés dans un objet spécifique de type AWSECommerceServicePortType.

Cette initialisation peut prendre un certain temps, et nous devrons gérer cette attente dans notre code JavaFX pour ne pas frustrer l'utilisateur.

Il nous faut maintenant ajouter une méthode permettant d'effectuer la recherche d'item, en fonction du code UPC donné en paramètre :

public AmazonItem searchItem(String upcNumber) {
//On crée un objet décrivant la requête a effectuer
ItemLookup request = new ItemLookup();

//Saisie des paramètres de la requête comme la clé privée du compte AWS
request.setAWSAccessKeyId( "__VOTRE__CLEE__AWS__" );
request.setValidate( "False" );
request.setXMLEscaping( "Single" );

//Création d'un objet décrivant l'item recherché
ItemLookupRequest item = new ItemLookupRequest();
item.setIdType( "UPC" );
item.getItemId().add(upcNumber);
item.setSearchIndex("DVD");
item.getResponseGroup().add("Images");
item.getResponseGroup().add("ItemAttributes");
item.getResponseGroup().add("EditorialReview");

//Ajout de l'item décrit a la requête envoyée à AWS
request.setShared(item);
try
{
ItemLookupResponse response = m_AWSServicePort.itemLookup(request);

/*On récupère le premier et l'unique Item car un numéro UPC étant unique on ne peut avoir qu'un résultat.*/
Item tmpItem = response.getItems().get(0).getItem().get(0);

//On utilise ici un objet que nous avons crée nous même beaucoup plus
//simple que le Item de AWS, car le notre ne contient que le titre, le
//synopsis et la jaquette du DVD
AmazonItem newItem = new AmazonItem();
newItem.setImageUrl(tmpItem.getLargeImage().getURL());
newItem.setTitre(tmpItem.getItemAttributes().getTitle()); newItem.setDescription(tmpItem.getEditorialReviews().getEditorialReview().get(0).getContent());

return newItem;
}
catch (Exception ex)
{
System.out.println("Caught Exception: " + ex.getLocalizedMessage());
}

return null;
}

Voici pour la partie Java, le code ci-dessus est commenté pour décrire chacune des lignes présentes.

Nous allons maintenant utiliser JavaFX pour interagir avec l'utilisateur, et appeler notre méthode de recherche d'item Amazon au besoin.
Sans nous attarder longuement sur la présentation graphique à l'aide de JavaFX, nous allons préciser comment lier les scripts JavaFX au code Java rédigé plus tôt :

Tout d'abord nous créons un nouveau projet dans NetBeans, de type Application JavaFX, puis nous lui ajoutons une nouvelle référence dans ses librairies : le projet Java créé précédemment.
Il nous suffit ensuite, en haut de la page de script JavaFX de faire un import des classes voulues, de la même manière qu'un import Java standard :

import ws.AmazonItem;
import ws.WebServiceControler;

Le reste est assez simple puisque l'on va appeler nos fonctions Java au milieu du code du script de façon transparente.
Nous initialisons la connexion au serveur d'Amazon dans un thread séparé pour pouvoir effectuer une animation de chargement en parallèle :

var wsControler : WebServiceControler;

public class AWSConnector extends Thread {

public override function run():Void {
try {
wsControler = new WebServiceControler();
} catch (ex) {
System.out.println("exception: {ex}");
}
}
}

Lorsque la connexion est terminée, nous affichons le champ de saisie (pour le code UPC) et le bouton de validation. Puis lors d'un clic sur le bouton de validation nous utilisons le code suivant :

var searchButton : SwingButton = SwingButton {
text: "Lancer la recherche"
onMouseClicked: function( e: MouseEvent ):Void {
try {
var currentItem : AmazonItem;
currentItem = wsControler.searchItem(upcTextField.text);
showDescription(currentItem);
} catch (myException:Exception) {
System.out.println("exception: {myException}");
}
}
}

Aussi simple que ça :)

Le résultat final est le suivant :
Lancement de la phase d'initialisation et animation de chargement (le nuage se déplace tant que la connexion n'est pas effective)

Puis le résultat une fois que le code UPC a été saisi et que le bouton "Lancer la recherche" a été pressé :

Conclusion :
Ce lab met donc en avant la possibilité de réaliser, avec la solution de Sun Microsystem, des consommations de WebServices dont nous ne connaissons pas la technologie support.
JavaFX est sorti en première version, il y a quelques semaines, mais son support du code Java standard lui permet d'hériter des possibilités de son ainé en terme de communication sur le web, qui existent depuis plusieurs années maintenant.
L'utilisation de JavaFX pour réaliser cette application nous offre le choix des modalités de déploiement : ce sera une application lourde ou une application web.

L'ensemble du code des labs sera bientôt disponible, nous n'attendons que la validation du projet par SourceForge.

Mais qui suis-je ?

2008-12-13T16:14:00.000-08:00

Dans le but d'offrir un service performant, complet et surtout standardisé, nous nous sommes penché sur le problème de l'authentification.
Nous pourrions créer un système d'identification propre à notre portail, mais cela ferme la porte à la communication inter-service sur internet. Dans le cadre de l'interopérabilité, ciblée depuis le départ, il apparaît donc évident d'offrir aux utilisateurs le moyen de s'authentifier avec leurs identifiants habituels. Ce sont ceux qu'ils utilisent tous les jours sur des sites comme Google, Windows Live...

L'authentification consiste en la saisie de vos identifiants. Une requête est alors envoyée à un serveur d'authentification, qui valide ou non votre identité. Il devient alors possible d'accéder à vos informations, comme votre nom, votre prénom... Ceci nous permettrait donc d'offrir des options à nos utilisateurs, sur le portail de VOD, telle l'option "Conseiller ce film à un ami", proposant la liste des contacts du compte Windows Live, par exemple.

Certains identifiants (notamment Windows live ID) sont disponibles pour les clients lourds. En revanche, certains ne sont utilisables qu'à l'aide de clients légers, comme par exemple des applications web ASP ou JSP.

Ainsi, je vais vous présenter quelques uns des nombreux services d'authentification existant en ligne et leurs particularités :

- Windows Live ID
Cet identifiant est celui utilisé par les services Windows (msn, azure...), au travers notamment, du Passport .Net pour les clients lourds.
Ce mode d'authentification est très facile à implémenter, notamment sous environnement .Net et J2EE (avec JSP).
Vous pouvez télécharger les SDK de Windows Live ID à l'adresse suivante :
http://dev.live.com/liveID/default.aspx

- Open ID
Ce système d'authentification offre une authentification unique à tous vos sites. Ainsi, en vous authentifiant sur OpenID, vous vous identifiez aussi sur votre compte Windows Live, sur votre compte Yahoo, ainsi que sur tout autre site ayant accepté le lien entre OpenID et leurs services.
Néanmoins, il semblerait que ce système ne soit accessible que depuis un client léger, ce qui limite son utilisation aux seuls sites web.
Une des originalités de ce service réside dans l'utilisation d'une URL comme identifiant. Par exemple, l'URL suivante est l'identifiant OpenID que j'utilise pour mes tests : http://cloudisgood.myopenid.com/ . Cette URL donne aussi accès à mon espace personnel, sur lequel je peux diffuser des informations.
Téléchargez les librairies OpenID Authentication pour Java et .Net aux adresses suivantes :
http://code.google.com/p/openid4java/
http://code.google.com/p/dotnetopenid/

- Google Account
Ce mode d'authentification offre un accès à son compte Google. Comme pour Windows Live, il est possible de l'implémenter dans une application lourde, et dans des applications webs.
Son utilisation ouvre les portes aux services Google, comme Blogger, Gmail...
Vous pouvez trouver plus d'informations sur l'API Account Authentication de Google et son implémentation à l'adresse suivante :
http://code.google.com/intl/fr/apis/accounts/

A noter : la plupart des services d'authentification ne permettent pas la saisie du mot de passe directement dans l'application cliente, pour des raisons de sécurité évidentes. Par conséquent, l'utilisateur saisi ses informations dans une page web du serveur d'authentification (exemple : OpenID), ou directement dans une fenêtre applicative indépendante de l'application cliente (exemple : Windows Live).

Conclusion
Il est donc relativement facile d'offrir à nos utilisateurs une authentification simplifiée au travers de leurs identifiants habituels. Nous développons ainsi l'étendue du service que nous offrons.
Je vous présenterai prochainement comment s'authentifier auprès de Windows Live, au travers d'un Lab .Net et Java !

Lab 1 : Amazone, belle Amazone.

2008-12-02T03:49:00.000-08:00

A travers ce lab je me propose de vous présenter une petite application permettant de récupérer des informations (titre, jaquettes, résumé…) sur des DVD en fonction de leur Universal Product Code (UPC).

Fig 1 : Exemple de l'application

Environnement de développement :
* Microsoft Visual C# 2008 Express Edition
* .NET Framework 3.5
* C# Library for Amazon Associates Web Service

Temps nécessaire : 30 minutes.

Note : Cette application vise à valider l’utilisation des Amazon Web Services dans notre architecture, en ce sens elle est simpliste et le code présenté à juste un objectif pédagogique.

La première chose à faire est de créer un Amazon Web Services Account sur http://aws.amazon.com/ afin de récupérer votre Access Key ID et votre Secret Access Key.

On peut ensuite créer notre application Windows Forms et ajouter notre librairie à la solution (via ajouter -> projet existant -> AmazonECS.csproj).

Une fois que votre fenêtre est faites, on va pouvoir ajouter le code nécessaire à la demande d'information et au traitement de la réponse.

Lors de chaque requête, il faut transmettre nos clés d'accès à amazon. Ces clés ainsi que l'adresse du site que l'on souhaite interroger sont encapsulés dans un objet AmazonECSQuery.


String accessKeyId = "votreAcessKeyId";
String secretAccessKey = "votreSecretAccessKey";

service = new AmazonECSQuery(accessKeyId, secretAccessKey, AmazonECSLocale.FR);

On définit ensuite ce que l'on souhaite obtenir dans un objet ItemLookupRequest


var requete = new ItemLookupRequest();
//On recherche par UPC
requete.IdType = "UPC";
// des DVDS
requete.SearchIndex = "DVD";
//On veut les images
requete.ResponseGroup.Add("Images");
//Les attributs de l'item (titre, auteurs, producteur...)
requete.ResponseGroup.Add("ItemAttributes");
// Les avis éditoriaux contient notre résumé
requete.ResponseGroup.Add("EditorialReview");
//On ajoute l'indentifiant que l'utilisateur à saisit dans la textBox;
requete.ItemId.Add(TextBox1.Text);

J'ai ensuite créé une classe qui effectue la requête et traite les résultats via la méthode suivante :


public void trouve(AmazonECS service, params ItemLookupRequest[] request)
{
try
{
/*Si la requête retourne une erreur(numéro UPC qui n'existe pas par exemple), on passe dans le catch*/
ItemLookupResponse response = service.ItemLookup(request);

/*Items contient des informations qui ne nous intéressent pas dans cette exemple comme le nombre de résultats. On récupère le premier et l'unique Item car un numéro UPC étant unique on ne peut avoir qu'un résultat.*/
Item item = response.Items[0].Item[0];

//si le numéro Amazon Standard Identification Number (ASIN) est retourné
if (item.IsSetASIN())
{
//on l'affiche
maFenetre.TextBox2.Text = item.ASIN;
}

if (item.IsSetMediumImage())
{
/*la propriété ImageLocation d'une PictureBox permet d'afficher une image à partir de son URL*/
maFenetre.PictureBox1.ImageLocation = item.MediumImage.URL;
}

if(item.IsSetItemAttributes())
{
maFenetre.TextBox3.Text = item.ItemAttributes.Title;
}

if(item.IsSetEditorialReviews())
{
/*La première case du tableau Editorial Review correspond a notre premier item; On en récupère le contenu;*/
maFenetre.TextBox4.Text = item.EditorialReviews.EditorialReview[0].Content;
}
}
catch (AmazonECSException ex)
{
MessageBox.Show("Caught Exception: " + ex.Message);
}
}

Pour cet exemple je n'ai pas fait de classes métier DVD et j'affiche directement les valeurs retournés dans les champs. Si vous souhaitez tester votre application, voici une base de données permettant de rechercher des UPC.

Il est aussi très intéressant de capturer les trames et de regarder le dialogue avec amazon.

Si vous souhaitez récupérer d'autres champs, la documentation amazon sera d'une aide préçieuse.

Le code source de l'application est disponible sur simple demande e-mail.

Pour conclure, mon impression est qu'il serait trés simple d'utiliser les WS Amazon pour récuperer des informations sur des films et que cela serait une plus value intéressante pour notre projet.

Rendez vous la semaine prochaine pour un nouveau lab sur.... une surprise !

Le troisième mousquetaire

2008-11-30T09:45:00.000-08:00

Nous avons proposé, dans notre architecture, de nous appuyer sur les Web Services d'Amazon pour récupérer les informations de chaque vidéo disponible à la location. Ces informations regrouperaient le titre, le casting complet du film, le synopsis ainsi que l'affiche.

Ce choix présente selon nous deux avantages :

Faciliter l'ajout de films à la base de données d'une boutique.
Maintenir à jour les informations de la base de donnée centrale.

De façon plus générale, il s'agirait d'ajouter un troisième grand nom des web services pour réaliser un projet interopérable mélant .Net, Java et AWS (Amazon Web Services).

Concrètement, nous utiliserions Amazon Associate Web Services pour obtenir la fiche film complète à partir du Code Universel Produit (souvent affiché sous forme d'un code-barres). La saisie du code barre se ferait dans une des boutiques de location qui interrogerait notre front office. Dans le cas où celui-ci ne connaîtrait pas encore ce film, il serait chargé de recueillir les informations depuis le service d'Amazon pour créer une nouvelle fiche qu'il conserverait. Cette fiche serait ensuite utilisée à la fois par les magasins et par le site de VOD.

Chaque Web Service externe que nous choisirons d'utiliser sur ce projet sera testé au préalable sur Cloud it up. A ce titre, un logiciel sachant communiquer avec Amazon devrait trouver le chemin du blog dans les prochains jours, suivi dès la semaine prochaine par un autre utilisateur de Web Services.

Jouons aux légos !

2008-11-27T13:51:00.000-08:00

Une brique dans une brique dans une brique, elle-même dans une brique... Cela nous donne ? Un service de Video On Demand mettant en place de l'interopérabilité entre une application J2EE et une plate-forme de services Azure.

Sur l'architecture ci-dessus, nous pouvons voir le serveur applicatif J2EE associé à un serveur GlassFish, qui nous permettra l'administration du portail. Les données et blobs situés sur la base de données SQL Server seront transmis à la plate-forme de services Azure qui les accueillera grâce à ses SQL Services (merci Azure !).

Les communications entre les .Net Services et l'application J2EE se feront à l'aide du protocole SOAP.

Notre application située dans les nuages utilisera le Web service Amazon S3 afin d'obtenir des informations sur les films stockés (jaquettes, synopsis, noms des acteurs...).

Enfin, le client pourra se connecter sur une application Silverlight à l'aide de ses identifiants Windows Live, et bénéficiera de notre VOD.

Espérons que les murs tiendront... Néanmoins, les fondations ont l'air solides !

Une école dans les nuages

2008-11-22T10:40:00.000-08:00

Au cours de notre dernière année à l’EPSI Montpellier et grâce à un partenariat avec Microsoft, un enseignement sur le Cloud Computing a pu être mis en place pour l’option génie logiciel.

Au terme d’un programme de 24h de cours et td, M. Sfartz, architecte en système d’information chez Microsoft et M. Martos, professeur de Génie Logiciel Avancé à l’EPSI ont donné à leurs étudiants un projet.

Ce projet intitulé « TonTube » a pour but de mettre en pratique toutes les notions acquises pendant ces cours et travaux dirigés. La société «TonTube » est une société de location de DVD (600 magasins) souhaitant s’exporter sur internet. L’objectif de la société est donc de développer une application de type vidéothèque, permettant à chaque internaute de louer et visionner sa vidéo en ligne. Il sera bien sûr nécessaire de lier le site de Video On Demand aux applications back office de gestion des magasins.

Notre équipe projet est composée de 4 étudiants, tous en dernière année à l’EPSI Montpellier : Maxime Britto, Mathieu Chenu, Léo Pratlong et Sébastien Sapet.

Toutes les informations que vous trouverez sur ce blog auront pour but d’illustrer l’avancement de notre projet, et de vous présenter l’architecture, les technologies et les moyens utilisés dans ce projet de Cloud Computing et d’interopérabilité.