Option Transversale Microsoft, Technologies .NETLivre blancDéveloppement d’une application client àl’aide de Silverlight e...
1SommairePrésentation .......................................................................................................
2Déploiement et hébergement..................................................................................................
3Présentation ContexteTwitter est l’un des nombreux réseaux sociaux que l’on peut trouver sur la toile, à ceci prèsqu’on l...
4.NET intermédiaire, qui elle permet l’utilisation de ces API, afin d’échanger avec l’applicationSL. Cependant, la manière...
5Serveur : twitter.com•Fournit un ensemble d’API dites RESTful, qui correspond à l’ensemble des fonctionnalités coeurs de ...
6L’architecture générale peut se résumer sur le schéma suivant :  Architecture serveur twitter.comLes API RESTful de échan...
7     Architecture middlewareL’architecture middleware (intergicielle) a pour but de fournir au client Silverlight des ser...
8    Prérequis et outils     ServicesLe développement de l’application WCF se fait à partir de l’environnement Visual Stud...
91) Un projet WCF Service Application (Visual C# - .NET 4). Dans l’implémentation que   nous décrivons, il sera nommé WSCo...
10    Ce projet contiendra :    -   Les mêmes classes que celles utilisées dans le projet WSConnection.Entities.Web, par  ...
11Afin de faciliter le débogage des services lors des développements, nous utiliserons le projetClass Library Twitterizer2...
12A partir de maintenant, vous pourrez faire utiliser les méthodes et objets de Twitterizer2 depuisles fichiers sources du...
13                   Figure 1: Fenêtre de configuration du projet WSConnection.Entities.Web                 Figure 2: Fenê...
14                                                                                 un utilisateur authentifié,            ...
15 → TwitterUser et TwitterUser → User). Pour ce faire, nous allons utiliser une classe d’utilitaires de conversions (stat...
16                                          identifiant                                     -    Listes d’utilisateurs : u...
17services. Ainsi, il va nous falloir utiliser les avantages des deux types d’élément service : lecouple interface/classe ...
18    {        #region ITwitterStatusService Members        public Status Delete(Status twitterstatus)         {          ...
19les exceptions, alors cela ferait « planté » le client. Dans le cas d’un client web, cela semanifeste généralement par l...
20Veillez à configurer le pare-feu afin qu’il autorise les connexions entrantes HTTP si voussouhaitez rendre accessibles v...
21Pour installer le framework .NET 4, il faut que vous l’ayez installé sur votre poste. Si vous nel’avez pas, téléchargez-...
22Double-cliquez ensuite sur la fonctionnalité Exploration de répertoire et cliquez sur « activez »qui apparaîtra dans la ...
23Le fichier Web.config contient alors (des balises essentielles ont volontairement été ôtées parsouci de clarté, mais don...
24 Figure 8 : Extrait dune timeline montrant des twitts précisant le nom de lapplication ayant utilisé les API de Twitter....
25Les identifiants de l’application sont les clés Consumer key et Consumer secret. C’est grâce àelles que pour chaque comm...
26En bleu : base du lien pour récupérer les messages privés.En vert : paramètres d’identification d’un utilisateur ; commu...
27Pour une vue plus globale sur le workflow de la méthode OAuth, veuillez vous référer audiagramme suivant :Les paramètres...
28 TestsLes tests font l’objet d’une part importante du développement des services, dans la mesureoù d’une part l’architec...
29 Figure 11 : Fiddler2 pour le débogage Web (appels des services de WSConnection.Web, appels des API RESTful de          ...
30Ajoutez le service Authentication.svc que nous avons publié sur le serveur IIS7 local, dans lerépertoire virtuel /WSConn...
31On remarque que le type de la valeur de retour est bien le type contenu et déclaré dans lesclasses de la librairie de cl...
32Cependant, notons que dans le cas des tests, il faut changer la valeur du timeout au boutduquel le client considère que ...
33Notez également les valeurs de maxReceivedMessageSize qui correspondent à la taille          desmessages reçus, typiquem...
34Implémentons alors l’événement click comme suit :private void buttonStatus_Click(object sender, RoutedEventArgs e)      ...
35             {                  MessageBox.Show(e.Message);             }         }Le résultat, s’il s’est bien passé (a...
36                         Figure 14 : Vue sur la page principale de Twittomator  Initialisation de la solutionLe projet c...
37 Ce projet contiendra : -   Les fichiers sources du projet Blacklight, nous utiliserons notamment les composants     Dra...
38   lieu permet de gérer plusieurs « DragDockPanel » et d’effectuer des opérations sur les   fenêtres qu’il contient.   I...
39En l’occurrence pour Twittomator, nous utiliserons le thème « Expression Light » inclut dans letoolkit, et ce de la mani...
40qui n’est pas le cas des cookies) ou en mode OOB (Out of Browser). Chaque applicationSilverlight peut avoir à sa disposi...
41                  settings.Add(name, value);              settings.Save();       }   }  Intégration des services WebIl v...
42                ProgressStart();                stBar.Text = "Friends list";                WsTwitterUser.TwitterUserSer...
43     MOOB (Mode Out of browser)Le mode OOB permet aux applications Silverlight de pouvoir s’exécuter comme uneapplicatio...
44Figure 15 : Twittomator en mode OOB (installation)Figure 16 : Twittomator en mode OOB (exécution)
45Déploiement et hébergementLes solutions (solution WSConnection et solution Twittomator) sont déployées sur un serveurWin...
46                                 Figure 17 : Environnement Windows 2008 R2  Installation de WCFL’installation se fait de...
47Dans notre cas, nous envoyons les sources du projet WSConnection.Web par un serveur ftpintermédiaire, puis nous les récu...
48La spécification de .NET 4 sur architecture 64bits diffère légèrement de celle sur 32bits, ce quinous oblige à adapter c...
49Figure 18 : contenu du fichier debug.txt dont le nom et ladresse sont indiqués en tant que paramètre de lapplication WCF...
50      <grant-to>        <resource path="/" include-subpaths="true"/>      </grant-to>    </policy>  </cross-domain-acces...
Tutoriel : Développement d&rsquo;une application client à l&rsquo;aide de Silverlight et WCF
Prochain SlideShare
Chargement dans…5
×

Tutoriel : Développement d&rsquo;une application client à l&rsquo;aide de Silverlight et WCF

3 713 vues

Publié le

How-To / Livre blanc de dernière année, rédigé par deux ex étudiants de l'INSA Lyon (département Informatique).

Description pas à pas de l'architecture et du développement, sous forme de tutoriel, de la mise en place d'un client pour Twitter utilisant la technologie Silverlight 4.

Page officielle : http://eucalyptus.hsouiba.info/2011/04/twittomator-le-livre-blanc/

Contributeurs :
- Hicham SOUIBA / @hsouiba
- Saad BENBOUZID / @makavelikal

Publié dans : Technologie
0 commentaire
0 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

  • Soyez le premier à aimer ceci

Aucun téléchargement
Vues
Nombre de vues
3 713
Sur SlideShare
0
Issues des intégrations
0
Intégrations
12
Actions
Partages
0
Téléchargements
103
Commentaires
0
J’aime
0
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive

Tutoriel : Développement d&rsquo;une application client à l&rsquo;aide de Silverlight et WCF

  1. 1. Option Transversale Microsoft, Technologies .NETLivre blancDéveloppement d’une application client àl’aide de Silverlight et WCF : twittomator v1.0 bBENBOUZID Saad et SOUIBA Hicham 2010
  2. 2. 1SommairePrésentation ......................................................................................................................................... 3 Contexte ........................................................................................................................................... 3 Problématique ................................................................................................................................ 3 Objectifs ............................................................................................................................................ 4 Le projet ............................................................................................................................................ 4Concepts .............................................................................................................................................. 4 Vue globale ................................................................................................................................. 4 Architecture serveur twitter.com ........................................................................................... 6 Architecture middleware......................................................................................................... 7 Architecture cliente ................................................................................................................... 7 Pré-requis et outils .......................................................................................................................... 8 Services ......................................................................................................................................... 8 Client .............................................................................................................................................. 8Services ................................................................................................................................................. 8 Initialisation de la solution ............................................................................................................ 8 Projet Twitterizer2 .......................................................................................................................... 10 Librairies de classes ...................................................................................................................... 12 Projet WSConnection.Web ........................................................................................................ 14 Services ....................................................................................................................................... 14 Configuration du serveur web.............................................................................................. 19 Tests .................................................................................................................................................. 28 Tests fonctionnels...................................................................................................................... 28 Tests pour client Silverlight ...................................................................................................... 31Client.................................................................................................................................................... 35 Fonctionnalités .......................................................................................................................... 35 Initialisation de la solution ...................................................................................................... 36 Blacklight, Silverlight Toolkit et ressources externes ........................................................ 37 Enregistrement d’information côté client : Isolated Storage ...................................... 39 Intégration des services Web ............................................................................................... 41 Mécanisme de Callback (twitter) ....................................................................................... 42 MOOB (Mode Out of browser) ............................................................................................. 43
  3. 3. 2Déploiement et hébergement..................................................................................................... 45 Configuration IIS ........................................................................................................................... 45 Installation de WCF .................................................................................................................. 46 Installation de .NET4 ................................................................................................................. 46 Déploiement du projet WSConnection.Web ................................................................... 46 Déploiement du client Twittomator .................................................................................... 49 Accès et sécurité ..................................................................................................................... 49Evolutions ............................................................................................................................................ 50 Généricité ...................................................................................................................................... 50 Déploiement .................................................................................................................................. 51Remerciements ................................................................................................................................. 51
  4. 4. 3Présentation ContexteTwitter est l’un des nombreux réseaux sociaux que l’on peut trouver sur la toile, à ceci prèsqu’on le reconnaît plus pour le microbloging (publication et partage de très courts articles, laplupart faisant référence à une page web dans laquelle se trouve de plus amplesinformations). Comme tout réseau social, il possède une communauté d’utilisateurs (environ12 millions aujourd’hui), dont l’interaction entre ces derniers et le réseau Twitter se faitprincipalement depuis le portail Web proposé par le groupe : twitter.com.Cependant, à l’image d’autres réseaux sociaux populaires (par exemple facebook), Twitterpropose à ses utilisateurs de pouvoir utiliser les fonctionnalités proposées par le portail web, etplus encore, grâce à une architecture orientée services pour le Web (REST : RepresentationalState Transfer). ProblématiqueLa plateforme Twitter propose aux développeurs – amateurs et professionnels –, et a fortiori àdes applications tierces et indépendantes de la société Twitter de pouvoir utiliser sesfonctionnalités sans avoir à naviguer sur son portail Web. Ceci présente l’avantage de laisserle soin à des applications clientes de se détacher des guides de styles et de navigationproposées par le portail web de Twitter. Néanmoins, Twitter demeure le fournisseur etinterlocuteur exclusif avec lequel les applications clientes devront communiquer. Parconséquent, l’hôte exécutant une application cliente – c’est-à-dire consommatrice desservices proposées par – devra disposer au minimum d’une connexion Internet et del’autorisation d’accès au domaine twitter.com.Les services proposés par Twitter sont des services web dits REST (on parle alors de en tant quesystème RESTful), qui se basent sur l’échange de données aux formats XML, objets JAVAsérialisés ou JSON, via protocole HTTP. Cependant, il existe d’autres types de services webnormalisés, se distinguant de l’architecture REST, qui sont standardisés par des protocoles decommunication et d’échanges différents. C’est le cas du protocole SOAP (Simple ObjectAccess Protocol), ou plus largement WSDL pour la description des services, dont les échangesse font par fichiers XML sur protocole HTTP.Ce protocole est principalement utilisé par les outils Microsoft et l’architecture de servicesweb .NET. De plus, il sera plus évident d’utiliser ce format d’échange dans le casd’applications clientes développées en .NET.Cette solution vient au problème qui a été de rendre compatible l’utilisation des nombreusesAPI pour Twitter écrites en .NET que l’on peut trouver en versions libres sur la toile (twitterizer,linq2twitter, ...), mais incompatibles avec Silverlight. Après avoir envisagé la solution deréécrire et modifier le code source de ces API afin de rendre possible leur exécution dansune application Silverlight, il est apparu que c’était impossible du fait du trop haut niveau duframework Silverlight (SL), qui s’affranchit et interdit les procédures et appels cœurs de cesAPI, qui se situent au niveau des couches réseaux. L’idée a alors été d’utiliser une application
  5. 5. 4.NET intermédiaire, qui elle permet l’utilisation de ces API, afin d’échanger avec l’applicationSL. Cependant, la manière la plus adaptée pour l’échange de données et l’appel defonctions distantes demeure les services web. En conséquence de quoi l’intermédiaire choisiest une application web service WCF, utilisant .NET 4 (pour des raisons de compatibilitésoptimales avec l’application web Silverlight 4 cliente utilisant .NET 4 également). ObjectifsDans la mesure où nous développerons un client utilisant la technologie Microsoft Silverlight 4,sur framework .NET 4, nous utiliserons un fournisseur de services compatible et adapté àSilverlight 4, à savoir WCF (Windows Communication Foundation) .NET 4.Le fournisseur de services WCF sera chargé de proposer à des clients .NET (Web : Silverlight,ASP, etc. ou clients lourds : applications fenêtres (WinForms, WPF, etc.), applications consoles,etc.) les services qu’offre l’architecture REST de. Pour cela, le cœur de son développementsera basé sur la conversion et la personnalisation de services REST vers SOAP. Il jouera le rôled’intergiciel (Middleware) secondaire entre le domaine twitter.com et l’application cliente.Notons cependant qu’une librairie implémentant les appels REST de sera utilisée, sous formed’API (Application Programming Interface) pour .NET. Cette librairie jouera le rôle d’intergicielprimaire.Le client .NET que nous développerons utilisera les fonctionnalités de en communicant grâceà l’intergiciel secondaire (WCF .NET 4) et aura l’avantage de présenter quelquesfonctionnalités du nouveau framework Silverlight 4. Le projetDans le cadre du projet de l’Option Transversale « Technologies Microsoft » nous avons optépour la création d’un client Silverlight, reprenant tous les points qui viennent d’être cités ci-dessus. L’idée de base était non pas de créer un autre client (comme il en existe tellement !)mais un client pour la twittoma (twittosphère marocaine) qui viendrait s’incruster dans unprojet à moyen terme que l’on compte lancer. La maintenabilité ainsi que la flexibilité del’outil s’avèrent donc primordiales.Deux personnes ont travaillé conjointement pour mettre en place cette première versionbêta de twittomator : - Saad BENBOUZID - Hicham SOUIBAConcepts Vue globaleL’architecture complète repose sur une architecture client-serveur dans laquelleinterviennent des intergiciels. Dans le cadre du projet, ces entités sont les suivantes :
  6. 6. 5Serveur : twitter.com•Fournit un ensemble d’API dites RESTful, qui correspond à l’ensemble des fonctionnalités coeurs de twitter (publication d’un statut, lecture de statuts, gestion des suivis, etc.).•Communique en lecture-écriture sur le protocole http, avec échanges de fichiers au format JSON.•L’ensemble du domaine, les bases de données et le code source des API sont privés.Intergiciel primaire : twitterizer2•Librairie .NET d’objets et de méthodes pour utiliser et communiquer avec les API RESTful de twitter (protocole HTTP et format des fichiers d’échange JSON).•Librairie incompatible avec Silverlight (3 et 4). Librairie compatible .NET 2.0+.Intergiciel secondaire : WCF•Application web WCF .NET 4, incluant et utilisant la librairie twitterizer2.•Hébergée sur serveur web IIS7.•Services publiés sur annuaire public.•Services utilisables uniquement par l’hôte client (celui qui héberge l’application Silverlight cliente) : restriction de domaine pour les requêtes SOAP.Librairie de classes pour l’échange des objets (espace de noms commun)•Contient une librairie de classes pour Silverlight (Silverlight Class Library) pour l’échange et l’utilisation des objets communs avec l’application web WCF.•Contient une librairie de classes pour Silverlight (Silverlight Class Library) pour l’échange et l’utilisation des objets communs avec l’application SIlverlight cliente.Application cliente Silverlight 4•Projet Web développé à l’aide du framework Silverlight 4.•Hébergée sur serveur web IIS7.
  7. 7. 6L’architecture générale peut se résumer sur le schéma suivant : Architecture serveur twitter.comLes API RESTful de échangent avec l’API .NET twitterizer2 des fichiers au format JSON surprotocole HTML.Les API proposées par sont nombreuses et exhaustives par rapport aux fonctionnalités offertespar le réseau social. Les différentes fonctionnalités sont découpées en méthodes, recenséesau sein de groupes de méthodes. A titre d’exemple, le groupe account recensera lesméthodes associées à la gestion d’un profil utilisateur (update_profile, update_profile_image,etc.). De plus, on distingue en amont des familles de groupes de fonctions, qui sont aunombre de deux : api (qui contient les groupes cœurs : users, statuses, account, friendship,…) et search (qui contient les groupes pour les méthodes de recherches et de statistiques).Le wiki de, accessible à l’adresse http://apiwiki.twitter.com/Twitter-API-Documentation,permet d’avoir une vue détaillée sur la spécification de chaque fonction, agrémentéed’exemples.Typiquement, l’appel d’une méthode se fait depuis l’adresse http :http://[famille_de _groupes].twitter.com/1/[groupe_de_fonctions]/[fonction].json?[paramètres]ou bienhttp://[famille_de_groupes].twitter.com/1/[groupe_de_fonctions]/[fonction]/[paramètre_de_fonction].json?[paramètres]
  8. 8. 7 Architecture middlewareL’architecture middleware (intergicielle) a pour but de fournir au client Silverlight des servicesWeb utilisant WCF, afin de faciliter les échanges entre twitter.com et le client, et donc afortiori d’alléger considérablement le développement des fonctionnalités cœurs du client.Elle est découpée en deux intergiciels distincts : - Un intergiciel chargé d’échanger des méthodes de l’API twitter.com dans le format proposé par celui-ci, à savoir selon le principe RESTful. En résumé, c’est une interface .NET pour Twitter. Il s’agit d’un projet .NET (2.0+) open-source sous licence BSD1, dont le développement est toujours en cours (dernière version : Twitterizer2.0, 03/04/2010 – site officiel du projet : http://code.google.com/p/twitterizer). - Un intergiciel WCF chargé de communiquer avec twitter.com en utilisant l’intergiciel précédent. Il proposera une version quasi semblable des méthodes proposées par twitterizer2, à ceci près qu’elles seront adaptées afin d’utiliser des objets qu’un projet Silverlight peut également utiliser (ce qui n’est pas le cas pour twitterizer2), et qu’elles seront publiées sous forme de services Web. Ce sera finalement cet intergiciel qui sera utilisé par le client Silverlight, ou tout autre client développé en langage .NET.Les éléments caractéristiques et distincts entre ces deux intergiciels seront explicités dans unautre chapitre de ce document. Architecture clienteL’architecture client se résume en l’interface Utilisateur qui va permettre à ce dernier depouvoir se loguer et effectuer des opérations sur son compte Twitter (envoyer des twitts,accéder à sa « time line » ainsi qu’à celle de ses amis …).Dans la mesure où nous disposerons ces informations via des composants avancés deSilverlight et que l’on va acquérir les données via WCF, un niveau moyen est requis :connaître les différents types de conteneurs, la programmation évènementielle et lamanipulation de services web WCF. Les tutoriaux disponibles sur le site officiel de Silverlighthttp://www.silverlight.net/learn/tutorials/ permettront aux débutants d’acquérir lescompétences requises.1 http://www.opensource.org/licenses/bsd-license.php
  9. 9. 8 Prérequis et outils ServicesLe développement de l’application WCF se fait à partir de l’environnement Visual Studio2010 2. Il faudra également disposer de Microsoft .NET Framework 4 3 . Par ailleurs, dans lamesure où le client (proxy) consommateur des services Web ne s’exécute pas forcément surle même hôte que celui qui héberge les services, il est très conseillé de ne pas utiliser leserveur web de Visual Studio (UtilDev Cassini Web Server 4 ) mais Microsoft IIS 5 (InternetInformation Service).Le développeur devra satisfaire d’une expérience en développement orienté objet enlangage C#, ainsi que d’une expérience dans le développement, la maintenance et lapublication de services Web WCF sur serveur IIS. Pour des informations sur l’utilisation de cestechnologies, veuillez-vous référer à au chapitre «Remerciements» en fin de document. ClientEn termes d’outils utilisés côté client, il est nécessaire de disposer de la dernière version endate de Visual Studio 2010 (en version RC à lheure où ces lignes sont écrites), du SDKSilverlight 4, du runtime client, et de manière facultative, Expression Blend 4 (en version béta àl’heure actuelle, on peut toujours envisager de créer l’interface graphique à l’aide deMicrosoft Silverlight Tools intégré à VS 2010 et le SDK Silverlight).Microsoft a mis au point une plateforme tout en un qui permet de télécharger tous les outilsprécédemment cités via un installeur commun : Microsoft Web plateforme, disponible àl’adresse suivante http://www.silverlight.net/getstarted/. Cette plateforme ne concerne pourl’instant que la version 3 de Silverlight, il faut mieux pour l’instant privilégier une installationmanuelle comme c’est expliqué sur cette page :http://www.silverlight.net/getstarted/silverlight-4/.ServicesCe chapitre va décrire succinctement la marche à suivre afin de disposer d’un serveur deservices Web pour utiliser les API de twitter.com, ce du développement à la publication, enpassant par les tests. Initialisation de la solutionLe projet consiste en une solution disposant de plusieurs projets :2 http://msdn.microsoft.com/en-us/vstudio/dd582936.aspx3 http://www.microsoft.com/downloads/details.aspx?FamilyID=a9ef9a95-58d2-4e51-a4b7-bea3cc6962cb&displaylang=en4 http://p-gaudin.developpez.com/tutos/cassini5 http://www.iis.net
  10. 10. 91) Un projet WCF Service Application (Visual C# - .NET 4). Dans l’implémentation que nous décrivons, il sera nommé WSConnection.Web. Notons également qu’un projet ASP.NET Web Application de Visual Studio fait également l’affaire ; l’important étant qu’il puisse contenir des éléments Silverlight-enabled WCF Service.Ce projet contiendra :- les services et leur implémentation,- la configuration du serveur Web (fichier Web.config)- la référence vers les sources de twitterizer2 (en mode debug) ou vers la version compilée (dll) de twitterizer2 (en mode release).2) Un projet Class Library (Visual C# - .NET 4). Il sera nommé WSConnection.Entities.Web.Ce projet contiendra :- les classes utilisées par les services, qui correspondent aux objets métiers de Twitter (classes User, Status, DirectMessage, etc.). A noter qu’il ne s’agit pas des mêmes classes que celles utilisées et déclarées par twitterizer2.3) Un projet Silverlight Class Library (Visual C# - .NET 4). Il sera nommé WSConnection.Entities.Silverlight.
  11. 11. 10 Ce projet contiendra : - Les mêmes classes que celles utilisées dans le projet WSConnection.Entities.Web, par référence symbolique (liens vers fichiers) afin de conserver un contenu rigoureusement identique. 4) Un projet Silverlight Application (Visual C# - .NET 4) pour les tests uniquement. Il sera nommé Test. Ce projet contiendra : - L’application Silverlight (la page web unique, au format xaml, généré par défaut à la création du projet sera suffisante). Notons que le fichier aspx (ou html) chargé de lancer le projet dans un navigateur web est stocké dans le projet web de la solution, à savoir WSConnection.Web (inutile de créer un second projet web).La solution, que nous avons nommé WSConnection, se compose alors des projets suivants :Important : veillez à ce que vos projets soient configurés pour utiliser .NET 4. Dans le cascontraire, modifiez le paramètre depuis la fenêtre de propriétés du projet concerné puisrecompilez afin de pallier aux éventuels conflits entre références croisés de projets utilisantdes versions différentes de .NET. Projet Twitterizer2Twitterizer2 est disponible en téléchargement sous la forme d’une solution Visual Studio 2008,ayant un projet librairie de classes (Class Library) contenant les sources. Elle estaccompagnée de divers projets « démos » (web, console, winform, …) afin de permettre àl’utilisateur de tester ses fonctionnalités sous différents cas d’utilisation. Cependant, la librairiede classes n’est utilisable que pour des projets .NET (que ce soit en référence sur le projetClass Library en question, ou sur la dll correspondant à la version compilée du projet ClassLibrary). Ainsi, un projet Silverlight ne peut utiliser directement twitterizer2, ce qui nous oblige àpallier à ce problème en passant par un intermédiaire (le projet WCF WSConnection.Web).
  12. 12. 11Afin de faciliter le débogage des services lors des développements, nous utiliserons le projetClass Library Twitterizer2 dans notre solution, et nous y ferons référence depuis le projetWSConnection.Web. Dans le cas contraire, il nous aurait suffi de faire référence à la dlltwitterizer2.dll compilée et incluse dans le répertoire de génération du projet twitterizer2.Sélectionnez ensuite le projet Twitterizer2 dans la solution téléchargée.A présent, il ne reste qu’à référencer le projet dans le projet WSConnection.Web.
  13. 13. 12A partir de maintenant, vous pourrez faire utiliser les méthodes et objets de Twitterizer2 depuisles fichiers sources du projet WSConnection.Web au moyen de l’inclusion using Twitterizer2;.Nous n’allons pas décrire le fonctionnement de cet API. Le lecteur trouvera une descriptionapprofondie sur le site6 de l’éditeur. Librairies de classesIl s’agit de deux librairies WSConnection.Entities.Web et WSConnection.Entities.Silverlight, quise basent sur les mêmes classes, et mieux encore, sur les mêmes fichiers. Cependant, chaqueprojet générera sa propre DLL.En effet, WSConnection.Entities.Web.dll devra être utilisé par le projet contenant les services,WSConnection.Web, et WSConnection.Entities.Silverlight.dll par le projet client Silverlight, enl’occurrence le projet Tests pour les tests. Le lecteur remarquera que cette fois-ci nous faisonsréférence aux DLL (.dll) et non plus aux projets (.csproj), ceci pour deux raisons : 1) Les dll contiennent des classes qui n’ont pas de méthodes à débugger : les classes ne contiennent que des propriétés et des constructeurs. 2) Les projets consommateurs des classes ne possèdent pas forcément les sources des projets WSConnection.Entities.Web et WSConnection.Entities.Silverlight ou l’auteur ne souhaite pas les distribuer afin de s’assurer qu’elles ne soient pas modifiées et que l’architecture entre projets utilisateurs et projets utilisés gardent sa cohérence.Afin d’utiliser les librairies WSConnection.Entities.Web et WSConnection.Entities.Silverlight dansrespectivement WSConnection.Web et Tests, il va falloir les référencer dans les projets.Mais avant cela, il faut veiller à ce que les deux projets librairies utilisent le même espace denoms.Renseignez le champ Default namespace pour les deux projets (WSConnection.Entities.Webet WSConnection.Entities.Silverlight), depuis la fenêtre de configuration du projet (clic droit surla racine du projet > Propriétés), avec comme nom WSConnection.Entities.6 http://code.google.com/p/twitterizer/wiki/GettingStarted
  14. 14. 13 Figure 1: Fenêtre de configuration du projet WSConnection.Entities.Web Figure 2: Fenêtre de configuration du projet WSConnection.Entities.SilverlightA présent, il faut créer les classes métiers à partager entre les deux librairies. Nous n’allons pasfournir le code de ces classes, car le lecteur pourra les retrouver dans le code source de lasolution WSConnection qui lui est fourni avec ce document.Cependant, nous allons présenter les correspondances entre les classes métiers utilisées parTwitterizer2 et celles utilisées (mutuellement) par WSConnection.Entities.Web etWSConnection.Entities.Silverlight. La différence majeure réside dans le fait que les classes desdeux dernières librairies ne contiennent pas de méthodes mais que des constructeurs, et lerapport réside dans le fait qu’ils se partagent les mêmes propriétés, ce afin d’obtenir et destocker les mêmes résultats entre les services de WSConnection.Web et Twitterizer2.WSConnection.Entities Twitterizer2 DescriptionDirectMessage TwitterDirectMessage Message directDirectMessageCollection TwitterDirectMessageCollection Collection de message(s) direct(s)Status TwitterStatus Statut (ou « twitt »), limité à 140 caractères par TwitterStatusCollection TwitterStatusCollection Collection de statut(s)User TwitterUser Utilisateur du réseau tweeterUserCollection TwitterUserCollection Collection d’utilisateur(s)Tokens OAuthTokens Ensemble de clés propre à
  15. 15. 14 un utilisateur authentifié, qui sont rappelés dans chaque requête vers twitter.com. (voir OAuth pour plus de détails sur cette méthode d’authentification7).Figure 3 : Correspondance entre les objets de lespace de nom WSConnection.Entities (échangés entre les services et les clients), et les objets du projet Twitterizer2 (API .NET pour Twitter) Projet WSConnection.WebCe projet constitue le seul projet Web de la solution. Il contiendra en plus des services web laconfiguration du serveur, et de ses services. Notons que le projet contient une page web pardéfaut, ainsi qu’une page web pour le lancement du projet client Silverlight (de test) Tests. ServicesNous allons présenter l’ajout des services web au projet, sans entrer dans le détail dudéveloppement.Tout d’abord, distinguons les éléments de services des autres éléments en créant un dossierdans le projet qui contiendra les éléments services.Nommez-le Services.Une problématique se pose : le projet Twitterizer2 (espace de nom Twitterizer) chargé decommuniquer avec twitter.com manipule ses propres objets, qui ne sont pas les mêmes queceux des librairies de classes (espace de nom WSConnection.Entities), cf. tableau decorrespondance précédent. Cependant, les classes ont les mêmes propriétés, ce quifacilitera les conversions d’objets.En effet, il va falloir utiliser des méthodes pour « convertir » un objet d’une classe deWSConnection.Entities en un objet d’une classe de Twitterizer, et vis-versa (par exemple User7 http://oauth.net
  16. 16. 15 → TwitterUser et TwitterUser → User). Pour ce faire, nous allons utiliser une classe d’utilitaires de conversions (static) qui permettra de convertir à la volée et dans les deux sens un objet de Twitterizer en son objet de WSConnection.Entities correspondant. La classe se présente avec les en-têtes de fonctions suivants : public class ConversionUtilities { static public void CompleteConsumerKeys(Tokens tokens); static public Tokens CreateTokensFromOAuthTokens(OAuthTokens oat); static public OAuthTokens CreateOAuthTokensFromTokens(Tokens at); static public User CreateUserFromTwitterUser(TwitterUser tu); static public Status CreateStatusFromTwitterStatus(TwitterStatus ts); static public DirectMessage CreateDirectMessageFromDirectMessageCollection( TwitterDirectMessage tdm); static public StatusCollection CreateStatusCollectionFromTwitterStatusCollection( TwitterStatusCollection tsc); static public UserCollection CreateUserCollectionFromTwitterUserCollection( TwitterUserCollection tuc); static public DirectMessageCollection CreateDirectMessageCollectionFromTwitterDirectMessageCollection( TwitterDirectMessageCollection tdmc); } Vous pouvez créer cette classe dans n’importe quel espace de nom du projet WSConnection.Web. Dans notre cas, nous l’avons créé dans WSConnection.Web.Services (espace de nom qui contient également les services). Avant de les créer, détaillons les différents services que le projet WSConnection.Web va devoir produire. Rappelons que les différents services vont faire appel à l’API (le projet) Twitterizer2, et utiliser les objets des librairies de classes de l’espace de nom WSConnection.Entities. La classe de conversion ConversionUtilities sera donc utilisée dans chaque service, et chacune de leurs procédures.Nom du service Fonctions principales Classes WSConnection.Entities utiliséesAuthentication - Authentifications - TokenResponse - Demande d’autorisation à - UriLink twitter.com (grant access) - Demande du lien hypertexte d’autorisation - …TwitterDirectMessageService - Envoi de statuts (twitts) privés à des - DirectMessage utilisateurs - DirectMessageCollection - Gestion de sa boîte de réception (twitts reçus par d’autres utilisateurs) : lecture et suppression - …TwitterStatusService - Lecture de timelines (flux de twitts) : - Status personnelle, publique d’amis - StatusCollection (followers), etc. - Gestion de twitts personnels : rédaction, publication, republication, suppression, etc. - …TwitterUserService - Gestion d’un profil utilisateur. - User - Gestion des "amis" : possibilité de - UserCollection suivre ou d’arrêter de suivre un utilisateur. - Recherche d’utilisateurs par nom ou
  17. 17. 16 identifiant - Listes d’utilisateurs : utilisateurs suivis, utilisateurs suiveurs - Liste des twitts que vous avez publiés et que d’autres utilisateurs ont - StatusCollection republié. - …Figure 4 : Liste des services et descriptions succinctesNote : TokenResponse contient un ensemble de clés renvoyées par twitter.com suite à une authentification avec succès via le portail web twitter.com. Ces informations devront être stockées et conservées par le client, une fois leurs avoir été rendues par le service invoqué. UriLink est une structure :public struct UriLink public enum ReturnCodes { { public ReturnCodes returnedCode; OK, PROBLEM public Uri returnLink; }; }; Elle correspond au lien renvoyé par le service lors d’une demande d’accès (grant access) à twitter.com de la part du client.A présent, ajoutons les services. Pour cela, ajoutez dans le répertoire Services du projetWSConnection.Web des éléments Silverlight-enabled WCF Service que vous nommerez de la mêmemanière que ceux listés dans le tableau précédent, en veillant à conserver l’extension (.svc) originale.Les différences entre un service de type WCF Service et Silverlight-enabled WCF Service se situent auxniveaux suivants : Silverlight-enabled WCF Service WCF ServiceService - Un service NomDuService est par - Un service NomDuService est composé par défaut composé d’une classe défaut d’une classe NomDuService.svc.cs NomDuService.svc.cs (pas et d’une interface INomDuService.cs listant d’interface). les méthodes que NomDuService.svc.cs implémentent.Compatibilité8 - Le service est ajouté dans la - Le service est ajouté dans la configuration configuration du serveur web du serveur web (fichier Web.config à la (fichier Web.config à la racine du racine du projet), avec les paramètres projet), avec les paramètres pour utiliser à la fois le fichier de classes adéquats pour utiliser WCF et rend (.svc.cs) et l’interface (.cs). Cependant le service compatible pour ASP.NET cette configuration ne rend pas le service et clients Silverlight. compatible pour clients Silverlight. Figure 5 : Différence entre deux éléments "service" de Visual Studio pour un projet WebIl est conseillé d’utiliser une interface pour un ou plusieurs services donnés, afin d’avoir unemeilleure vue sur son développement et permettre des implémentations génériques de8 Source : http://www.dotnetcurry.com/ShowArticle.aspx?ID=228&AspxAutoDetectCookieSupport=1
  18. 18. 17services. Ainsi, il va nous falloir utiliser les avantages des deux types d’élément service : lecouple interface/classe et la configuration pour ASP.NET et Silverlight.Donc vous avez soit la possibilité de : - Créer un service Silverlight-enabled WCF Service, et créer manuellement un fichier d’interface que vous prendrez soin de citer en tant que contrat dans la configuration du serveur pour ce service (fichier Web.config). - Créer un service WCF Service et changer le mode de connexion dans la configuration du serveur pour ce service (fichier Web.config) : mode d’attachement (binding) à changer pour le point d’accès (endpoint) pour ce service (passer de wsHttpBinding à basicHttpBinding ou customBinding).Nous avons choisi de procéder selon la première alternative.Afin de publier une méthode dans un service, il faut préciser la directive [OperationContract].A noter qu’une méthode statique (static) ne peut être utilisée. C’est d’ailleurs la raison mêmequi nous empêche d’utiliser directement les méthodes de Twitterizer2, car la plupart d’entreelles sont déclarées statiques ; ce qui nous oblige à implémenter des méthodes (de mêmesnoms) d’appel.A titre d’exemple, voici les différents éléments, non exhaustifs, du service TwitterStatusService(les éléments essentiels ont été saisis en gras).----------------------------------- ITwitterStatusService.cs ------------------------------using WSConnection.Entities;namespace WSConnection.Web.Services{ [ServiceContract] public interface ITwitterStatusService { [OperationContract(Name = "Delete")] Status Delete(Status twitterstatus); [OperationContract(Name = "DeletePrivate")] Status Delete(Tokens tokens, long id); [OperationContract(Name="GetHomeTimeLine")] StatusCollection GetHomeTimeline(); [OperationContract(Name = "GetHomeTimeLinePrivate")] StatusCollection GetHomeTimeline(Tokens tokens); //... }}-------------------------------------------------------------------------------------------Notez que des noms personnalisés ont été donnés aux méthodes dans leurs versions publiées,car en effet le protocole SOAP est basé sur XML dont la syntaxe ne permet pas de gérer lessurcharges de méthodes (de noms identiques).----------------------------------- TwitterStatusService.svc.cs ---------------------------using WSConnection.Entities;namespace WSConnection.Web.Services{ [AspNetCompatibilityRequirements(RequirementsMode =AspNetCompatibilityRequirementsMode.Allowed)] public class TwitterStatusService : ITwitterStatusService
  19. 19. 18 { #region ITwitterStatusService Members public Status Delete(Status twitterstatus) { // … } public Status Delete(Tokens tokens, long id) { // … } public StatusCollection GetHomeTimeline() { // … } public StatusCollection GetHomeTimeline(Tokens tokens) { // … } }}-------------------------------------------------------------------------------------------A titre d’exemple, voici l’implémentation d’une des méthodes (Delete) public Status Delete(Status twitterstatus) { TwitterStatus ts; try { ts = new TwitterStatus { Tokens =ConversionUtilities.CreateOAuthTokensFromTokens(twitterstatus.Tokens), Id = twitterstatus.Id } .Delete(); return ConversionUtilities.CreateStatusFromTwitterStatus(ts); } catch (Exception) { return null; } }Explication : 1) Création d’un objet TwitterStatus de Twitterizer. 2) Utilisation de l’objet à partir de paramètres de WSConnection.Entities préalablement converti pour Twitterizer. 3) Utilisation de l’objet de Twitterizer qui exécute sa fonction avec l’API de twitter.com (suppression d’un statut («twitt») dans ce cas). 4) Récupération de la valeur de retour de l’objet Twitterizer (dans notre cas, renvoie l’élément correspondant à l’objet supprimé en cas de succès (TwitterStatus), et l’objet null en cas d’échec. 5) La valeur de retour est convertie en un objet Status de WSConnection.Entities et renvoyé.Nous remarquons que le code des méthodes est dans la mesure du possible exécuté dansdes espaces traitant les exceptions (try {} catch {}). Bien qu’une erreur non gérée ou fatalene fasse pas « tomber » le serveur, ou nécessite un redémarrage du service serveur web, si lecode d’appel des services côté client n’est lui-même pas contenu dans des espaces traitant
  20. 20. 19les exceptions, alors cela ferait « planté » le client. Dans le cas d’un client web, cela semanifeste généralement par l’arrêt de l’exécution des scripts sur la page avec affichage parle navigateur de la mention Erreur sur la page. Il faut alors ou relancer le navigateur si le clientest développé en utilisant des sessions et variables de sessions, ou tout simplement rechargerla page.La spécification entre le client (Silverlight) et le serveur (WCF) veut que tout appel ayant subiun échec dans son exécution renvoie l’objet null, et ce même en cas d’erreur (gérée parTwitterizer2) renvoyée par twitter.com (par exemple : une erreur 401 en cas de demande desuppression d’un objet Status qui ne peut pas l’être : un twitt qui ne vous appartient pas, parexemple celui d’un «ami»).Partage d’objetsLe lecteur expérimenté de WCF se rendra sans doute compte que la directive [DataContract]et [CollectionDataContract] permettant la sérialisation9 d’objet n’a pas été utilisée dans nosservices. En effet, ce serait une des méthodes pour partager les classes deWSConnection.Entities, mais il présente l’inconvénient de n’être utilisable que si l’on nepossédait qu’un seul service.On voit par exemple que les services TwitterUserService et TwitterStatusService utilisent tousdeux les classes Status et StatusCollection. Ceci a pour conséquence pour le proxy (clientSilverlight) de manipuler deux types d’objets différents pour Status et deux types différentspour StatusCollection, bien qu’il s’agisse respectivement des mêmes objets. Ainsi, un objetStatus renvoyé par l’appel au service TwitterUserService ne pourra pas être utilisé en tant queparamètre pour le service TwitterStatusService. Une solution aurait été de faire en sorte quechaque service utilise des classes qu’aucun autre service n’utilise, et donc en en ôtant unebonne partie, mais ceci aurait réduit considérablement la richesse de l’API.Il existe une troisième manière de partager des objets : il s’agit de l’architecture WCF RiaServices (depuis .NET 4 et Silverlight 4), avec notamment l’utilisation d’une librairie de classesWCF RIA Services Class Library et des éléments services Domain Service Class. Pour de plusamples informations sur WCF Ria Services, vous pouvez vous référer à ces quelques liens 10. Configuration du serveur web PublicationNous avons la possibilité d’utiliser le serveur Web interne à Visual Studio 2010 (cassini), maisdans la mesure où la solution aura pour but d’être déployée sur un serveur web (IIS7), autantcommencer tout de suite afin d’éviter de configurer une deuxième fois les mêmes choses.Si ce n’est pas déjà fait, installez puis lancez le service IIS7.9 using System.Runtime.Serialization. (Using DataContracts) http://msdn.microsoft.com/en-us/library/ms733127.aspx10 (Creating a RIA Services Solution) http://msdn.microsoft.com/en-us/library/ee707376(v=VS.91).aspx (Learn About WCF RIA Services) http://www.silverlight.net/getstarted/riaservices/
  21. 21. 20Veillez à configurer le pare-feu afin qu’il autorise les connexions entrantes HTTP si voussouhaitez rendre accessibles vos services depuis d’autres hôtes. A priori, si vous testez vosservices sur votre poste de développement (projet Tests de la solution WSConnection parexemple), ce n’est pas indispensable.A présent, il faut publier le projet web (WSConnection.Web) sur IIS7. Pour cela, configurez leprojet de la manière suivante :Compilez la solution une première fois afin de publier le projet Web en tant qu’applicationASP.NET sur votre serveur IIS.Vous aurez peut-être besoin de configurer votre serveur IIS7 afin qu’il puisse utiliser MicrosoftFramework .NET 4 et WCF.
  22. 22. 21Pour installer le framework .NET 4, il faut que vous l’ayez installé sur votre poste. Si vous nel’avez pas, téléchargez-le depuis le site officiel de Microsoft.Exécutez ensuite :C:windowsMicrosoft.NETFrameworkv4.0.30128aspnet_regiis.exe -iPour installer WCF dans IIS7, exécutez la commande suivante :C:WindowsMicrosoft.NETFrameworkv3.0Windows Communication Foundation/ServiceModelReg.exe –iAprès compilation avec succès, testez WCF sur votre serveur IIS7 en accédant à l’un desservices. Par exemple Authentication.svc à l’adresse Authentication.svc Figure 6 : page web à ladresse http://localhost/WSConnection/Services/ Figure 7 : page web à ladresse http://localhost/WSConnection/Services/Authentication.svcNote :  azed est le nom d’hôte du PC utilisé pour le développement par les auteurs du présent document.  Si le serveur IIS refuse de vous lister les fichiers à l’adresse http://localhost/WSConnection/Services/, il faut que vous activiez l’exploration de répertoire dans le gestionnaire IIS.
  23. 23. 22Double-cliquez ensuite sur la fonctionnalité Exploration de répertoire et cliquez sur « activez »qui apparaîtra dans la barre d’actions à droite de la fenêtre.Autre méthode, veillez à avoir la balise (en gras) dans votre fichier Web.config :<!-- Avant --> <system.webServer> <!-- Avant --> <directoryBrowse enabled="true"/> <!-- Après --> </system.webServer><!-- Après --> Fichier Web.configLe fichier Web.config contient la configuration ASP.NET et WCF pour le projet web. Ce fichierest placé à la fois à la racine du projet, et donc à la racine du site virtuel créé lors à lapremière publication par Visual Studio 2010.Nous n’entrerons pas dans les détails pour ce fichier, qui peut permettre des configurationsrelativement fines et poussées, mais nous survolerons les paramètres de configuration pour leséléments qui nous intéressent pour notre projet WSConnection.Web.ServicesLes services sont publiés sur un annuaire par l’intermédiaire du protocole WSDL, et sont utiliséspar l’intermédiaire du protocole SOAP/XML.Les déclarations sont regroupées en trois parties :  les comportements,  les méthodes d’attachement,  les services.Prenons pour exemple la déclaration du service TwitterStatusService (possédant uneinterface ITwitterStatusService.cs et une classe implémentant ses fonctionsTwitterStatusService.svc.cs).
  24. 24. 23Le fichier Web.config contient alors (des balises essentielles ont volontairement été ôtées parsouci de clarté, mais dont la présence demeure indispensable dans le fichier) :<?xml version="1.0"?><configuration> <system.serviceModel> <behaviors> <serviceBehaviors> <behavior name="WSConnection.Web.TwitterStatusServiceBehavior"> <serviceMetadata httpGetEnabled="true" /> <serviceDebug includeExceptionDetailInFaults="false" /> </behavior> </serviceBehaviors> </behaviors> <bindings> <customBinding> <binding name="WSConnection.Web.TwitterStatusService.customBinding0"> <binaryMessageEncoding /> <httpTransport /> </binding> </customBinding> </bindings> <services> <service behaviorConfiguration="WSConnection.Web.TwitterUserServiceBehavior" name="WSConnection.Web.TwitterStatusService"> <endpoint address="" binding="customBinding" bindingConfiguration="WSConnection.Web.TwitterUserService.customBinding0" contract="WSConnection.Web.ITwitterStatusService"/> <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange"/> </service> </services> </system.serviceModel></configuration>Dans le cas de services Silverlight-enabled WCF Service, il a fallu créer manuellement lesfichiers interfaces. Il va donc de soi qu’il faille également modifier manuellement lesdéclarations des services dans le fichier Web.config. Utilisez TwitterStatusService pour exempleet faîtes de même pour les autres services.ASP.NETUtilisez les balises suivantes (en gras) afin d’autoriser ASP.NET pour le projet web, d’utiliser leframework .NET 4 et d’autoriser le débogage des services lors des exécutions en modedebug :<?xml version="1.0"?><configuration> <system.web> <compilation debug="true" targetFramework="4.0"/> <pages controlRenderingCompatibilityVersion="4.0" clientIDMode="AutoID"/> </system.web></configuration>ConstantesLe projet WSConnection.Web utilise quelques constantes. Il existe plusieurs manières destocker des constantes pouvant être modifiées à la volée par un administrateur du serveurweb sans nécessiter la recompilation de l’application (fichiers ressources (res, resx), fichiersplain text (xml, txt, ...), etc.). Il est également possible d’utiliser la section<appSettings></appSettings> du fichier Web.config.Les constantes à stocker sont les deux clés publiques identifiant l’application cliente surtwitter.com.En effet, twitter.com tient à connaître les clients utilisant ses API, et demande préalablementà l’utilisateur connecté au client utilisant les API d’autoriser l’application.
  25. 25. 24 Figure 8 : Extrait dune timeline montrant des twitts précisant le nom de lapplication ayant utilisé les API de Twitter. Dans le cas de l’utilisation du portail web http://twitter.com, le nom de l’application est Web.Avant cela, il faut créer une entrée d’application sur twitter.com depuis le compte utilisateurpropriétaire de l’application. Pour notre part, nous avons créé une application nomméetwittomator. Figure 9 : Clés publique et secrète de lapplication
  26. 26. 25Les identifiants de l’application sont les clés Consumer key et Consumer secret. C’est grâce àelles que pour chaque commande par l’API Twitterizer2 (qui communique directement avecles API RESTful de twitter.com), twitter.com sait quel est l’émetteur de la commande. Ainsi, untwitt émis par Twitterizer2 en utilisant la méthode Update du service TwitterStatusService feraapparaître la mention via Twittomator.Figure 10 : Affichage dun twitt publié depuis le portail Web twitter.com et depuis les services de WSConnection.Web, en utilisant Twitterizer2 (pour l’utilisateur twittomator).Le fichier Web.config contiendra alors les deux constantes de la manière suivante, enrappelant que l’accès depuis le code C# des éléments du projet WSConnection.Web à lasection appSettings de Web.config se fait par la commandeWebConfigurationManager.AppSettings["ConsumerKey"] etWebConfigurationManager.AppSettings["ConsumerSecret"] qui renvoient un type string.Communication avec twitter.comLes commandes envoyées à l’API RESTful de twitter.com par Twitterizer2 se distinguent endeux types de commandes :  Les commandes privées («OAuth requests»), qui demandent des informations et instructions propres à un utilisateur particulier, et qui nécessitent les identifiants («credentials» en anglais) de l’utilisateur. Par exemple : publication d’un twitt, suppression d’un twitt personnel, demande pour suivre un utilisateur, etc.  Les commandes publiques («regular requests»), qui elles ne demandent pas d’identifiants. Par exemple : consultation des twitts d’un ou de plusieurs utilisateurs dont le profil est public, recherche d’un utilisateur, etc.Les identifiants sont contenues dans le lien HTTP qui forme la commande à l’API RESTful.Exemple d’une commande privée (récupération des twitts privés (messages privés) reçusdans la boîte de réception d’un utilisateur) :http://api.twitter.com/1/direct_messages.json?since_id=[...]&max_id=[...]&count=[...]&[chaîne_d_authentification]En orange : paramètres propres à la commande pour récupérer les messages privés.
  27. 27. 26En bleu : base du lien pour récupérer les messages privés.En vert : paramètres d’identification d’un utilisateur ; commun et identique pour toutecommande privée.En noir : symboles utilisés dans une URL pour sérialiser plusieurs paramètres et leurs valeurs.Les paramètres pour l’identification (OAuth 11) contenant une suite de paramètres et leursvaleurs (…param1=[…]&param2=[…]&param3=[…]…).Les paramètres sont les suivants :Paramètre Descriptionoauth_consumer_key Clé publique identifiant l’application. Elle est récupérer à la déclaration de l’application dans twitter.com (via portail web), cf. figure 9.oauth_nonce Nombre aléatoire généré pour assurer l’unicité de la demande.oauth_signature_method Méthode de hash pour signer la valeur de signature, à partir de la clé secrète (Consumer secret, cf. figure 9). Twitter ne supporte que la méthode HMAC-SHA1, bien qu’il en existe d’autres comme par exemple RSA.oauth_timestamp La valeur de l’heure de la commande donnée dans la base de temps UNIX (Epoch Time).oauth_signature Valeur de signature générée à partir de la clé secrète de l’application, la méthode de signature, la valeur nonce, la valeur timestamp, la valeur oauth_consumer_secret, et la clé de l’utilisateur stockée chez le client (oauth_token_secret).oauth_token Clé publique de l’utilisateur reçue lors de la première connexion au portail web.oauth_version Version de la spécification de OAuth utilisée. Twitter utilise la dernière version qui est la 1.0.A noter que le client Silverlight ne possède, et n’est sensé conservé que ces clés. Elles doiventêtre données aux services pour chaque demande de commande privée) :  oauth_token (clé publique de l’utilisateur)  oauth_token_secret (clé privée de l’utilisateur, utilisée pour fabriquer oauth_signature, mais n’apparaît pas dans les url).Les services (le projet WSConnection.Web) ne possède que les clés privée et publique del’application (en tant que constantes dans Web.config)  oauth_consumer_key (clé publique de l’application)  oauth_consumer_secret (clé privée de l’application)Rappelons que les clés oauth_token et oauth_token_secret sont données au client lors de latoute première demande d’authentification. C’est ensuite à lui de les stocker (base dedonnées locale, fichier cookie, variables dans l’application, base de registres Windows, etc.).11 http://oauth.net et http://p2p.wrox.com/content/articles/twitter-development-oauth-specification
  28. 28. 27Pour une vue plus globale sur le workflow de la méthode OAuth, veuillez vous référer audiagramme suivant :Les paramètres de connexion de chaque commande (de Twitterizer2 vers twitter.com)dépendent de la méthode http utilisée : GET ou POST.Dans le cas d’une commande GET (demande d’informations : lecture de twitts, recherched’utilisateurs, etc.), tous les paramètres sont contenus dans l’url et très peu dans l’en-tête.Par ex : URL http://api.twitter.com/1/statuses/home_timeline.json?oauth_consumer_key=wqkLXN46UL ucOhQImtot8g&oauth_nonce=610190C&oauth_signature=lr4j1b3Tmhbvx7QrY%2B3njGlm P28%3D&oauth_signature_method=HMAC- SHA1&oauth_timestamp=1271002136&oauth_token=123179302- hk1YLrRzQxcbgczHWHlSHGBaVjyXVXbcGIOrRPlw&oauth_version=1.0 En-tête User-Agent: Twitterizer/1.0.0.0Dans le cas d’une commande POST (publication d’informations : rédaction d’un twitt, envoid’un message privé à un utilisateur, etc.), seuls les paramètres propres à la fonction sontcontenus dans l’url et la chaîne de connexion dans l’en-tête. URL http://api.twitter.com/1/statuses/update.json?status=Le%20statut%que%je%publie En-tête User-Agent: Twitterizer/1.0.0.0 Content-Type: application/x-www-form-urlencoded Authorization: OAuth realm="Twitter API",oauth_consumer_key="wqkLXN46ULucOhQImtot8g",oauth_nonce="73CC729E",oauth_signature_ method="HMAC-SHA1",oauth_timestamp="1271002459",oauth_token="123149312- hk1YLrRzFxcbgdcBBHlSHGBaVjyXFFdEEIOrFV3w,oauth_version="1.0"
  29. 29. 28 TestsLes tests font l’objet d’une part importante du développement des services, dans la mesureoù d’une part l’architecture bi-intergicielle est relativement complexe et nécessitel’assurance d’une parfaite adéquation et compatibilité, et d’autre part car nus devons êtresûrs que chaque commande de services renvoie un résultat en cas d’échec et de réussite.Chaque service est donc codé dans des espaces de traitements d’exceptions. Bien qu’il soitgénéralement inconcevable dans le développement d’une application réseauclient/serveur multi-tiers de connaître tous les cas d’erreurs et d’exceptions, la phase de testsdoit permettre d’en connaître les principaux :  erreurs dans le développement (valeurs null, boucles infinies, etc.),  erreurs dans les envois et retours entre Twitterizer2 et twiter.com (urls mal formées, erreurs http (401, 404, …), etc.).Les tests se distingueront en deux parties : 1) tests fonctionnels, dont le but est de s’assurer que chaque méthode fait ce qu’elle doit faire et renvoie ce qui est attendu. 2) Tests de compatibilité et de configuration pour Silverlight et .NET 4, afin de s’assurer que les services et leurs commandes puissent être invoqués depuis le client. Tests fonctionnelsPour les tests fonctionnels, il existe plusieurs façons de les exécuter :  depuis des clients développés rapidement (consoles, winforms, …),  depuis des clients spécialement prévus pour les tests de services WCF : WcfTesClient.exe  depuis des débogueurs Web, pour le débogage des échanges entre Twitterizer2 et twitter.com.
  30. 30. 29 Figure 11 : Fiddler2 pour le débogage Web (appels des services de WSConnection.Web, appels des API RESTful de twitter.com : GET/POST, etc.)Dans un premier temps, assurez-vous que les services soient en mode débogage dans VisualStudio 2010, en vérifiant, ou ajoutant, la ligne suivante dans votre fichier Web.config du projetWSConnection.Web :<system.web> <!-avant --> <compilation debug="true" targetFramework="4.0"> <!-après --></system.web>Il faut tester les fonctions et par les trois façons indiquées ci-avant. Nous en détailleronsqu’une, à savoir l’utilisation du client WcfTestClient livré avec Visual Studio (par défaut àl’adresse C:Program FilesMicrosoft Visual Studio 10.0Common7IDE).Pour commencer, connectez-vous à un service :
  31. 31. 30Ajoutez le service Authentication.svc que nous avons publié sur le serveur IIS7 local, dans lerépertoire virtuel /WSConnection/Services.Nous recevons alors toutes les fonctions du service (rappel : ce sont celles qui sont précédentdans la déclaration des interfaces, par la directive [OperationContract]).Nous allons à présent invoquer la première commande, qui permet de demander àtwitter.com le lien pour nous authentifier sur twitter.com et autoriser l’accès à notreapplication (nommée Twittomator, cf. figure 9). Cette fonction a l’avantage de ne pasdemander de paramètre, car elle se contente d’utiliser les constantes ConsumerKey etConsumerSecret présentent dans Web.config).Double-cliquez sur la fonction AskForAuthorizingLink() et cliquez ensuite sur le bouton Invoke.Le résultat est le suivant :
  32. 32. 31On remarque que le type de la valeur de retour est bien le type contenu et déclaré dans lesclasses de la librairie de classe WSConnection.Entities.Web (espace de nomWSConnection.Entities).Le type de retour est une structure (struct) dont la valeur returnedCode pouvait valoir soit OK,soit PROBLEM. Dans le cas d’un succès (OK), la valeur de returnLink vaut bel et bien l’url du lienpour la connexion.Notez aussi que dans l’onglet XML du client, vous pouvez avoir accès aux codes XML de larequête (du proxy/client) et de la réponse (du service).La seconde fonction du service (GetTokensFromOAuthTokens()) est chargée de donner àl’utilisateur les valeurs (OAuth) oauth_token et oauth_token_secret, à partir de la valeuroauth_token renvoyée par twitter.com. Vous pouvez alors entrer cette valeur directementdans la zone « paramètres » de l’invocation de la fonction pour la tester. Tests pour client SilverlightNous n’allons pas entrer dans le détail du développement d’une application Silverlight nidans l’invocation des services, car cette partie sera développée dans la suite du document.
  33. 33. 32Cependant, notons que dans le cas des tests, il faut changer la valeur du timeout au boutduquel le client considère que l’appel d’une fonction d’un service a échoué. En effet, étantdonné que l’on va déboguer notre ensemble depuis l’appel de la fonction d’un service(depuis le projet Silverlight Test), jusqu’à la réception de l’appel dans le service (projetWSConnection.Web), puis de WSConnection.Web à Twitterizer2, nous allons prendre du temps(F10/F11 dans Visual Studio) et sans aucun doute dépasser les « 1 minute » de timeout pardéfaut.Après avoir ajouté tous vos services, vous devez avoir la configuration projet suivante :A présent, éditez le fichier ServiceReferences.ClientConfig afin d’ajouter les valeurs detimeout qui ne sont pas présentes par défaut (receiveTimeout et sendTimeout) : <bindings> <customBinding> <binding name="CustomBinding_IAuthentication" receiveTimeout="00:10:00" sendTimeout="00:10:00"> <binaryMessageEncoding /> <httpTransport maxReceivedMessageSize="2147483647" maxBufferSize="2147483647" /> </binding> <binding name="CustomBinding_ITwitterStatusService" receiveTimeout="00:10:00" sendTimeout="00:10:00"> <binaryMessageEncoding /> <httpTransport maxReceivedMessageSize="2147483647" maxBufferSize="2147483647" /> </binding> <binding name="CustomBinding_ITwitterDirectMessageService" receiveTimeout="00:10:00" sendTimeout="00:10:00"> <binaryMessageEncoding /> <httpTransport maxReceivedMessageSize="2147483647" maxBufferSize="2147483647" /> </binding> <binding name="CustomBinding_ITwitterUserService" receiveTimeout="00:10:00" sendTimeout="00:10:00"> <binaryMessageEncoding /> <httpTransport maxReceivedMessageSize="2147483647" maxBufferSize="2147483647" /> </binding> </customBinding> </bindings>Ajoutez ensuite à votre page principale quelques composants (boutons, labels, grilles, etc.)afin de tester et afficher rapidement les résultats des commandes.Un temps de 10 minutes devrait être suffisant. Ces valeurs peuvent être modifiées à la guisedu lecteur.
  34. 34. 33Notez également les valeurs de maxReceivedMessageSize qui correspondent à la taille desmessages reçus, typiquement des listes (ou collections, ou tableaux) qui peuvent êtrevolumineux dans le cas de nombreux twitts à récupérer en une seule commande parexemple. Dans le cadre des tests qui se fait à partir d’un utilisateur de test qui n’a pasbeaucoup de twitts ni publiés ni à lire (de ses « amis »), une taille de 2 Go devrait être plusqu’amplement suffisante…Pour pouvoir lancer le client tout en débuggant les services, il faut configurer les projets Testet WSConnection.Web en tant que projets de démarrage, et désactiver le lancement d’unepage lors de l’exécution du projet WSConnection.Web. Figure 12 : Projets de démarrage Figure 13 : Désactivation de la page de démarragePlaçons un bouton et une grille pour récupérer une collection d’éléments.
  35. 35. 34Implémentons alors l’événement click comme suit :private void buttonStatus_Click(object sender, RoutedEventArgs e) { TwitterStatusService.TwitterStatusServ ts.GetHomeTimeLinePrivateCompleted += new EventHandler<TwitterStatusService.GetHomeTimeLinePrivateCompletedEventArgs> (ts_GetHomeTimeLinePrivateCompleted); ts.GetHomeTimeLinePrivateAsync(tokens); busyIndicator1.IsBusy = true; }La variable tokens est définie, par exemple au load de la MainForm, de la manière suivante :tokens = new Tokens { AccessToken = "123179302-hk1YLrR...XVXbcGIOrRPlw", AccessTokenSecret = "VLpJZcrSgY5Vk...50lbN0iN7JFqAc" };Elle est déclarée comme variable de classe.Tokens tokens;Le composant busyIndicator1 est utilisé afin de rendre compte du début et de la fin del’appel d’une commande.Le handler de l’appel est le suivant :public void ts_GetHomeTimeLinePrivateCompleted(object sender, TwitterStatusService.GetHomeTimeLinePrivateCompletedEventArgs e) { busyIndicator1.IsBusy = false; try { MessageBox.Show(e.Result.Count<Status>().ToString()); if (e.Result.Count<Status>() > 0) { UserCollection uc = new UserCollection(); uc.Add(e.Result[0].User); dataGrid2.ItemsSource = uc; } dataGrid1.ItemsSource = e.Result; } catch (Exception e)
  36. 36. 35 { MessageBox.Show(e.Message); } }Le résultat, s’il s’est bien passé (avec ou sans points d’arrêts), est le suivant :Après quelques tests des fonctions principales de chaque service (User, Status,Authentication, DirectMessage), sous différents contextes d’exécutions (envois massifs decommandes, exécutions simultanées depuis plusieurs navigateurs, connexion/déconnectionà Internet, etc.).Client FonctionnalitésVoici une liste de quelques fonctionnalités du client Silverlight dans sa première version béta : - Application Silverlight 4 en mode browser et out of browser - Authentification oath via Twitter - Affichage de la HomeTimeLine - Affichage des Mentions - Affichage des DirectMessages - Affichage des friends - Affichage des followers - Affichage de résultats de recherche - Envoi de twitts et limitation en temps réel du nombre de caractères restants - Url Shortner - …
  37. 37. 36 Figure 14 : Vue sur la page principale de Twittomator Initialisation de la solutionLe projet consiste en une solution disposant de plusieurs projets : 1) Le projet Silverlight Application (Visual C# - .NET 4) principal. Il sera nommé Twittomator. Ce projet contiendra : - L’application Silverlight en elle-même (front office côté utilisateur) avec toutes les vues nécessaires à l’application (connection, dashboard, templates) mais aussi les références aux services web offerts par la couche back office.On notera la création automatique d’un projet Web Twittomator.web qui contient les pagesaspx (et html) qui appellent le fichier Silverlight compilé (.xap) dans le répertoire ClientBindu projet Web. 2) Un projet Silverlight Application (Visual C# - .NET 4), nommé Blacklight Controls.
  38. 38. 37 Ce projet contiendra : - Les fichiers sources du projet Blacklight, nous utiliserons notamment les composants DragDockPanel et DragDockPanelHost personnalisés. - Le fichier de skin personnalisé.Blacklight, Silverlight Toolkit et ressources externes 1) Blacklight est un ensemble de contrôles (thèmes, animations, panels, players …) développés pour Silverlight disponible sur la forge des projets .NET de codeplex.com : http://blacklight.codeplex.com/Wikipage, en téléchargement gratuit. C’est un projet WPF et pas uniquement Silverlight, et le package à télécharger contient entre autres plusieurs exemples d’utilisations ainsi qu’un « showcase » (démo en ligne : http://mightymeaty.members.winisp.net/blacklight.silverlight/). Nous nous intéresserons au projet source nommé « Blacklight.Controls » et aux controls « DragDockPanel » et « DragDockPanelHost » : Les deux composants ci-dessus ont été personnalisés (thème) de manière à obtenir un nouveau contrôle Silverlight qui peut être réduit, maximisé, glissé et fermé. Cette fenêtre permettra d’afficher le résultat des différentes commandes utilisateur (timeline, mentions, direct message …). Le composant « DragDockPanel » quant à
  39. 39. 38 lieu permet de gérer plusieurs « DragDockPanel » et d’effectuer des opérations sur les fenêtres qu’il contient. Il suffit de rajouter la référence vers le projet Blacklight.Controls dans le projet courant et de rajouter la ligne suivante dans le XAML du UserControl : <UserControl xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" ... xmlns:controls="clr-namespace:Blacklight.Controls;assembly=Blacklight.Controls" ... > ... <controls:DragDockPanelHost x:Name="dragDockPanelHost /> ... </UserControl> [Se référer au code source pour en savoir plus sur la personnalisation de ce composant]2) A l’image de Blacklight, Silverlight Toolkit est un projet codeplex gratuit qui propose un ensemble de controls Silverlight avancés pour Silverlight 4 : datagrid, thèmes, childWindow, autocompletebox, etc. Il est disponible à l’adresse suivante http://mightymeaty.members.winisp.net/blacklight.silverlight/ , et un « showroom » de tous les contrôles est accessible ici : http://silverlight.net/content/samples/sl4/toolkitcontrolsamples/run/default.html
  40. 40. 39En l’occurrence pour Twittomator, nous utiliserons le thème « Expression Light » inclut dans letoolkit, et ce de la manière suivante :<UserControl xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"... xmlns:expressionLight="clr-namespace:System.Windows.Controls.Theming;assembly=System.Windows.Controls.Theming.ExpressionLight" ...><expressionLight:ExpressionLightTheme> <Grid x:Name="LayoutRoot" OpacityMask="White"> ... </Grid> </expressionLight:ExpressionLightTheme></UserControl>Nous utiliserons aussi le contrôle ChildWindow pour une fenêtre de type « about » : (SilverlightToolkit installe aussi des templates de composants dans l’assistant d’ajout). Enregistrement d’information côté client : Isolated StorageSilverlight utilise Isolated Storage, qui est un système de fichier virtuel qui permet de stockerdes informations applicatives de manière locale, chez l’utilisateur. C’est une meilleurealternative aux cookies, surtout lorsqu’il s’agit de travailler avec beaucoup de données àstocker. Aussi, il permet de partager les informations stockées depuis plusieurs navigateurs (ce
  41. 41. 40qui n’est pas le cas des cookies) ou en mode OOB (Out of Browser). Chaque applicationSilverlight peut avoir à sa disposition 1 MO d’espace (valeur par défaut extensible), à moinsqu’un administrateur n’ait prévu le contraire (c’est pour cela qu’il faut prévoir ce cas defigure dans son code).En l’occurrence, pour Twittomator, il est nécessaire de stocker au moins deux valeurs pour nepas avoir à se loguer à chaque fois. Voici comment utiliser l’isolated storage pour les valeurs« ConsumerKey » et « ConsumerKeySecret » en utilisant une classe statique :// Classe statique UserSettings qui utilise l’isolated storage public static class UserSettings { const string KEY1 = "ConsumerKey"; const string KEY2 = "ConsumerKeySecret"; const string NULLVALUE = "0"; // check si lutilisateur sest déjà connecté public static bool hasCredentials() { return ((Read((string)KEY1, NULLVALUE) != NULLVALUE) && (Read((string)KEY2, NULLVALUE) != NULLVALUE)); } public static Tokens returnCredentials() { Tokens tokens; tokens = new Tokens { AccessToken = Read((string)KEY1, NULLVALUE), AccessTokenSecret = Read((string)KEY2, NULLVALUE) }; return tokens; } public static void saveCredentials(string val1, string val2) { Write(KEY1, val1); Write(KEY2, val2); } public static TT Read<TT>(string name) { return Read<TT>(name, default(TT)); } public static TT Read<TT>(string name, TT defaultValue) { IsolatedStorageSettings settings = IsolatedStorageSettings.ApplicationSettings; TT value; if (settings == null || !settings.TryGetValue<TT>(name, out value)) return defaultValue; return value; } public static void Write<TT>(string name, TT value) { IsolatedStorageSettings settings = IsolatedStorageSettings.ApplicationSettings; if (settings == null) return; if (settings.Contains(name)) settings[name] = value; else
  42. 42. 41 settings.Add(name, value); settings.Save(); } } Intégration des services WebIl va de soi, et cela a été expliqué au début de ce document, que l’application Silverlightfera appel aux services web mis à disposition par le back office. Pour ce faire, nous nousdevons d’abord de rajouter les références aux services web dans le projet Twittomator, etcela de la manière suivante : 1) Faire un clic droit sur « References » et choisir « Add Service Reference » 2) Ajouter l’url du service Web (dans notre cas il est hébergé en local) et cliquer sur « Go ». Si l’opération se passe bien, l’assistant doit pouvoir lister les méthodes disponibles. Dans ce cas, donner un nom pour l’espace de noms (namespace) et valider. 3) Maintenant que la référence a été ajoutée, nous pouvons utiliser le nouveau namespace « WsTwitterUser » comme suit (il peut par exemple s’agir du bout de code correspondant au clic sur un bouton « Friends List ») :private void buttonFriends_Click(object sender, RoutedEventArgs e) { if (AddPanel(this.defaultMargin, this.moduleName, new LoadingAnimation())) {
  43. 43. 42 ProgressStart(); stBar.Text = "Friends list"; WsTwitterUser.TwitterUserServiceClient ts = new WsTwitterUser.TwitterUserServiceClient(); ts.GetFriendsCompleted += new EventHandler<WsTwitterUser.GetFriendsCompletedEventArgs>(ts_GetFriendsCompleted); // appel asynchrone à la fin ts.GetFriendsAsync(this.tokens); ProgressEnd(); } } 4) Handler qui se déclenche quand survient l’événement « completed »public void ts_GetFriendsCompleted(object sender, WsTwitterUser.GetFriendsCompletedEventArgs e) { try { if (e.Result.Count<User>()> 0) { string header = "Friends"; UserInfo users = new UserInfo(e.Result.ToList<User>()); this.panels[this.panels.Count - 1].Header = header; this.panels[this.panels.Count - 1].Content = users; } } catch (Exception ex) { MessageBox.Show(ex.StackTrace); } } Mécanisme de Callback (twitter)L’application twitter créée permet de spécifier une URL de « Callback ». Cette URL spéciale permet degérer le retour d’authentification de twitter et enregistre les paramètres qui lui sont retournés àl’aide de l’Isolated Storage.
  44. 44. 43 MOOB (Mode Out of browser)Le mode OOB permet aux applications Silverlight de pouvoir s’exécuter comme uneapplication Desktop classique. Pour pouvoir activer cette fonctionnalité, il suffit d’aller sur lespropriétés du projet Silverlight (Twittomator), d’activer le mode out of browser et derenseigner les informations sur l’application comme suit :Supposons que l’on veuille installer l’application via un bouton « install » qui détecte sil’application est installée ou pas lors de son lancement. Dans ce cas, voici le code à utiliserpour ce faire :// à l’initialisation de l’applicationif (Application.Current.InstallState == InstallState.Installed) { this.buttonInstall.Visibility = Visibility.Collapsed; }// au clic sur le bouton installprivate void buttonInstall_Click(object sender, RoutedEventArgs e){ Application.Current.Install();}Quand l’utilisateur clique sur le bouton « install », une fenêtre modale s’affiche et lui demandeles emplacements où il veut installer l’application :
  45. 45. 44Figure 15 : Twittomator en mode OOB (installation)Figure 16 : Twittomator en mode OOB (exécution)
  46. 46. 45Déploiement et hébergementLes solutions (solution WSConnection et solution Twittomator) sont déployées sur un serveurWindows 2008 R2 64 bits.Nous n’entrerons pas en détail sur la configuration du serveur, mais sur les points clés pour laconfiguration Silverlight, WCF et .NET 4.Pour la connexion au serveur (distant), nous utilisons un client TSE nommé Tunnelier, quipermet d’utiliser le protocole RDP à travers un proxy. L’objectif étant d’utiliser RDP lorsquevotre connexion à Internet directe ne vous le permet pas à cause de filtres sur ports etprotocoles (réseau d’entreprise, réseau universitaire, etc.). Le proxy utilisé l’hôte local sousSOCKS5, à travers du proxy forwarding depuis une connexion SSH distante. Configuration IISLe serveur distant possède un service IIS7. Il reste à la configurer afin qu’il puisse exécuter desapplications WCF/ASP.NET 4.
  47. 47. 46 Figure 17 : Environnement Windows 2008 R2 Installation de WCFL’installation se fait de la même manière que celle décrite dans ce qui précède dans cedocument (partie Projet WSConnection.Web/Services/Configuration IIS).Il faut s’assurer que .NET 3 soit installé et exécuter la commande :C:WindowsMicrosoft.NETFrameworkv3.0Windows Communication Foundation/ServiceModelReg.exe –i Installation de .NET4Pour installer le framework .NET 4, il faut veiller à prendre la version de l’architecture duserveur. Dans ce cas, ce sera la version x64 (à la différence de la version 32 bits utilisée sur lespostes de développement).Exécutez ensuite :C:WindowsMicrosoft.NETFrameworkv4.0.30128aspnet_regiis.exe –i Déploiement du projet WSConnection.WebIl faut livrer les sources du projet sur le serveur distant. Il existe plusieurs manières de le faire :  par connexion ftp (envoi depuis Visual Studio 2010 en tant que publication à chaque compilation). Méthode déconseillée dans le cas d’une toute première publication, mais bien pratique ensuite,  par connexion ftp directe (service ftp sur IIS7, puis envoi à partir d’un client ftp),  autres (envoi/réception à partir de serveurs de stockages, etc.).
  48. 48. 47Dans notre cas, nous envoyons les sources du projet WSConnection.Web par un serveur ftpintermédiaire, puis nous les récupérons à l’aide du client ftp filezilla depuis le serveur distant.Elles sont ensuite placées dans un répertoire local du serveur (par ex. C:inetpubwwwRoot).Notons que nous n’envoyons que le projet WSConnection.Web et pas les autres (Twitterizer2,WSConnection.Entities.WSConnection.Silverlight, WSConnection.Entities.Web), car ils sontprésents en versions compilées (DLLs) dans le répertoire bin du projet.Créons à présent le répertoire virtuel WSConnection sur IIS7 distant, à partir de la racineDefault Web Site.Il faut se connecter en tant qu’utilisateur ayant les droits sur le dossier à son emplacementphysique. Dans le cas de non mention d’un utilisateur, IIS utilisera l’identité anonyme pardéfaut IUSR, dont les droits (lecture/écriture) sur le chemin en question n’est pas assurée.Pour notre part, nous avons utilisé l’utilisateur Administrateur.
  49. 49. 48La spécification de .NET 4 sur architecture 64bits diffère légèrement de celle sur 32bits, ce quinous oblige à adapter certains paramètres du fichier Web.config. Dans notre cas, il s’agitseulement de la ligne :La directive pour autoriser le débogage doit être supprimée, car nous sommes à présent enmode release.<system.web> <!--avant--> <compilation debug="true" targetFramework="4.0"> <!--après--></system.web>A modifier ainsi :<system.web> <!--avant--> <compilation debug="false" targetFramework="4.0"> <!--après--></system.web>De plus, nous avons ajouté une fonction qui s’exécute et traite chaque exception (dans lesinstructions catch), et qui se charge de loger dans un fichier le libellé de chaque exception enplus de la date et heure, du nom du service concerné, et de la méthode dans laquellel’exception a eu lieu.
  50. 50. 49Figure 18 : contenu du fichier debug.txt dont le nom et ladresse sont indiqués en tant que paramètre de lapplication WCF, dans le fichier Web.config (veillez à avoir les droits sur le fichier) Déploiement du client TwittomatorOn procède de la même manière que pour le déploiement du projet WsConnection.web,mais cette fois ci avec le projet web Twittomator.web. Accès et sécuritéLa communication entre clients et services sur architecture WCF nécessite prend en comptedes paramètres de sécurité. Il en existe plusieurs, cependant nous n’en aborderons qu’unseul. Il s’agit des droits que donne une application de services WCF (en l’occurrenceWSConnection.Web) à des clients pour s’y connecter et les utiliser.Pour ce faire, le projet par l’intermédiaire de son fichier de configuration Web.config donnela possibilité d’autoriser ou d’interdire la communication SOAP avec certains clients. Cetteexclusion se concentre sur le domaine sur lequel se trouve l’appelant (le client, aussi appeléproxy).Cette configuration s’opère au niveau de deux fichiers : clientaccesspolicy.xml etcrossdomain.xml.Notez que si vous rencontrez même lors de la phase de tests (clients et services sur mêmeposte local (localhost)), veuillez paramétrer ces fichiers comme suit 12 pour garantir uneautorisation totale :----------------------------- clientaccesspolicy.xml -------------------------------<?xml version="1.0" encoding="utf-8"?><access-policy> <cross-domain-access> <policy> <allow-from http-request-headers="*"> <domain uri="*"/> </allow-from>12 Spécification conseillée par Microsoft (http://msdn.microsoft.com/en-us/library/cc645032(VS.95).aspx)
  51. 51. 50 <grant-to> <resource path="/" include-subpaths="true"/> </grant-to> </policy> </cross-domain-access></access-policy>-------------------------------------------------------------------------------------------Ceci indique que nous autorisons toutes formes de requêtes (« SOAP* », « X-API-* », etc.), etde toutes origines de clients.----------------------------- crossdomain.xml --------------------------------------<?xml version="1.0"?><!DOCTYPE cross-domain-policy SYSTEM "http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd"><cross-domain-policy> <allow-http-request-headers-from domain="*" headers="*"/></cross-domain-policy>-------------------------------------------------------------------------------------------Ceci indique que nous autorisons toutes origines de requêtes clientes. Ce fichier n’est pasindispensable, car il se contente d’écraser la configuration existante dansclientaccesspolicy.xml, au niveau de la balise <domain uri="*"/> et <allow-from http-request-headers="*">.Dans le cas du mode release, dans la mesure où le client Silverlight (Twittomator) et lesservices (WSConnection.Web) sont tous deux hébergés sur le même serveur, nous n’allonsautoriser que les requêtes locales. Par conséquent, indiquez le domaine du serveur dans lavaleur de l’attribut domain.Dans le cas de notre serveur, il s’agit de la configuration suivante : <allow-from http-request-headers="*"> <domain uri="http://lb-webpi-4976v.maplateformeweb.com"/> </allow-from> <cross-domain-policy> <allow-http-request-headers-from domain="*" headers="http://lb-webpi- 4976v.maplateformeweb.com"/> </cross-domain-policy>Les fichiers clientaccesspolicy.xml et crossdomain.xml doivent être placés à la racine duserveur web, c’est-à-dire dans le répertoire de Default Web Site dans notre cas. Ce répertoireest celui par défaut, à savoir C:inetpubwwwRoot.Evolutions GénéricitéLes services WCF ont l’avantage d’être utilisables par tout client développé en .NET4.Cependant pour être compatible avec des clients d’anciennes versions, il faudraitrecompiler les projets WSConnection.Web, WSConnection.Entities.Web sous .NET <4 (3.0 ou3.5). De même pour le projet WSConnection.Silverlight à compiler sous Silverlight 3. Dans cecas des clients SIlverlight 3 sous .NET 3+ pourront utiliser les services et les librairies de classes.

×