TimeOutException au travers d'une application n-tiers

Version imprimable

Bonnjour à tous,

Je développe actuellement une application dans une architecture n-tiers : UI(interface utilisateur), BLL (couche métier) et DAL (couche d'accès aux données).
Chaque couche communique avec les autres grâce à des services WCF suivant le schéma suivant:

UI <==> WCF service 1<==> BLL <==> WCF service 2 <==> DAL.

La seule communication entre les couches UI et BLL fonctionne parfaitement.

Mais quand je parcours tout le chemin dans l'application depuis la couche UI jusque la couche DAL (au travers du service WCF 1, la couche BLL et le service WCF 2) pour faire remonter un dataTable, j'ai une erreur de type TimeOutException.
Code:

1 2 3 4 5 This request operation sent to net.tcp://127.0.0.1:8000/MyServices/Service1 did not receive a reply within the configured timeout (00:01:00). The time allotted to this operation may have been a portion of a longer timeout. This may be because the service is still processing the operation or because the service was unable to send a reply message. Please consider increasing the operation timeout (by casting the channel/proxy to IContextChannel and setting the OperationTimeout property) and ensure that the service is able to connect to the client.
J'ai essayé juste pour tester, de communiquer directement entre la couche UI et la couche DAL grâce au service WCF 2, et ça marche, j'ai bien mon dataTable de remonté!
Cette erreur ne se produit que quand j'utilise les 2 services WCF pour faire remonter une info...

Pour info, le binding de mes services WCF est de type NetTcpBinding.

J'espère avoir été assez clair. Si vous pouviez à m'aider à régler ce problème très bloquant ce serait super! Merci d'avance!

17/03/2009, 09h56
obitskater

Bon j'ai un peu avancer dans le diagnostic de ce problème, et je me suis rendu compte que cette erreur ne se produit que lorsque j'utilise une winform pour héberger mes services, car quand j'utilise une applicatiion console comme hôte, tout marche bien...

Seul problème c'est que j'ai bien sûr besoin d'une winform comme hôte de mes services et non d'une console...:lol:

Une idée d'où ça peut venir?
17/03/2009, 10h10
Bluedeep

Comme ça non, mais ça peut être un vrai timeout ou une fausse barbe (timeout qui masque une erreur plus profonde).

Tu peux déjà :

- augmenter le timeout (c'est un paramètre optionnel à l'open du channel).
- spécifier la propriété IncludeExceptionDetailInFaults

Gére tu l'event Faulted coté client et coté serveur ?
17/03/2009, 10h30
obitskater

Salut BlueDeep, je ne pense pas que ce soit une erreur de timeOut, car comme dit plus haut "J'ai essayé juste pour tester, de communiquer directement entre la couche UI et la couche DAL grâce au service WCF 2, et ça marche, j'ai bien mon dataTable de remonté!".
Et ce en à peine 1 seconde. Donc que ça passe de 1 sec à plus d'une minute à cause d'une couche en plus à traverser, c'est moyen. En plus en utilisant ma console comme hôte, ça marche correctement en traversant toutes les couches, et ce toujours en 1 seconde.

Et sinon, oui je gère les faultsExceptions, en la levant sur le serveur quand il y a un problème et je la catch dans le client.
17/03/2009, 10h51
Gold Bug

Citation:

Envoyé par obitskater

Salut BlueDeep, je ne pense pas que ce soit une erreur de timeOut, car comme dit plus haut "J'ai essayé juste pour tester, de communiquer directement entre la couche UI et la couche DAL grâce au service WCF 2, et ça marche, j'ai bien mon dataTable de remonté!".
Et ce en à peine 1 seconde.

Une seconde c'est une éternité pour un ordinateur :aie:
17/03/2009, 10h56
Bluedeep

Et quand tu appel ta méthode, si tu mets un break, dans ta BLL, il transit bien à l'aller dans "WCF service 1" ?
17/03/2009, 11h08
obitskater

BlueDeep : Oui ça transite bien par le service 1, et la BLL, mais ça bloque au niveau du service 2, il ne passe pas dedans.

Gold Bug : Pas faux, mais c'était une façon de parler :mrgreen:, si tu veux je calculerais le temps réel de traitement pour te faire plaisir :king:
17/03/2009, 11h11
Bluedeep

Citation:

Envoyé par obitskater

BlueDeep : Oui ça transite bien par le service 1, et la BLL, mais ça bloque au niveau du service 2, il ne passe pas dedans.

Tiens, tiens.
Si tu remplaces ta DAL par un "bouchon" (tu prends une méthode au hasard et tu l'as fait retourner sans passer par la case DB), ca change quelque chose ?
17/03/2009, 11h14
Gold Bug

La mesure des performances est loin d'être anodine. Et parfois, des lenteurs correctement analysées peuvent mettre en relief un problème de design.
Je ne connais pas ton contexte, ni ce qui a motivé tes choix d'architecture, mais au vu de ce que tu nous présente, j'aurais tendance à te dire que ton design est très compliqué pour transférer une DataTable d'une BDD vers un front-end.

Personnellement, saisirais ces problèmes de timeout et de performances pour migrer vers un design plus simple avec moins de couches.
17/03/2009, 11h17
Bluedeep

Citation:

Envoyé par Gold Bug

Personnellement, saisirais ces problèmes de timeout et de performances pour migrer vers un design plus simple avec moins de couches.

La présence de couches ne suffit pas pour dégrader les performances de manière notable.

Et on peut penser que si il a opté pour une archi peu ordinaire (une couche WCF suplémentaire par rapport à d'habitude), c'est qu'il a une bonne raison non ? (il est vrai qu'en général on met la BLL coté client ou coté serveur d'appli, voire les deux souvent, mais rarement au milieu).
17/03/2009, 11h39
obitskater

Citation:

Envoyé par Bluedeep

Tiens, tiens.
Si tu remplaces ta DAL par un "bouchon" (tu prends une méthode au hasard et tu l'as fait retourner sans passer par la case DB), ca change quelque chose ?

J'ai déjà testé pour voir si le problème n'était pas lié à la BDD, j'ai donc pris la plus belle fonction du mode, un joli HelloWorld dans une classe de ma DAL... mais même problème...

Pour ce qui est de l'architecture choisie, elle n'est pas de mon ressort... Mais elle me paraît tout à fait appropriée au projet, découpage en couche pour séparer les tâches, plus de sécurité. Et la communication entre les couches en WCF, permettra si un jour le client ne doit plus être une appli lourde mais un site web, de n'avoir juste à réécrire le client.
En tout cas l'archi a été mise en place par les architectes, et je ne peux pas tout casser, et en plus c'est pas si con que ça :D
17/03/2009, 11h52
Gold Bug

Si ça peut t'aider

http://www.codeproject.com/KB/WCF/wc...86&msg=1825886
17/03/2009, 11h54
Bluedeep

Citation:

Envoyé par obitskater

Pour ce qui est de l'architecture choisie, elle n'est pas de mon ressort... Mais elle me paraît tout à fait appropriée au projet, découpage en couche pour séparer les tâches, plus de sécurité.

Le découpage encouche est standard pour n'imorte quel application "sérieuse" (il n'y a qu'ici où on voit des controles qu'on bind directement à la DB :? , pas dans la vie réelle).

Citation:

Et la communication entre les couches en WCF, permettra si un jour le client ne doit plus être une appli lourde mais un site web, de n'avoir juste à réécrire le client.

La dessus je suis plus réservé.

L'archi habituelle c'est DAL -> BLL Serveur (si nécessaire) -> WCF -> BLL Client -> UI

Si tu veux passer en client léger, tu remplaces juste la couche UI par un serveur WEB sans toucher au reste (c'est encore une fois l'archi standard pour une application).

POur en revenir à ton problème, peux tu passer les config client et serveur de tes contrats, STP.

Transferts tu les contextes de sécurité ? (problème de "double hop").

Citation:

Envoyé par Gold Bug

Si ça peut t'aider

http://www.codeproject.com/KB/WCF/wc...86&msg=1825886

Merci j'y jetterai un coup d'oeil cet après-midi, ça a l'air pas mal du tout.

Citation:

Envoyé par Bluedeep

POur en revenir à ton problème, peux tu passer les config client et serveur de tes contrats, STP.

Transferts tu les contextes de sécurité ? (problème de "double hop").

Voici le code de mes configs, je les crée dans le code car j'avais un problème de endPoints non trouvé. Voici une verison "Light" de test:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
 
 
 class Program
    {
        static void Main(string[] args)
        {
            InitInfoIpAdress();
            initServicesBll();
            StartService(_serviceBll);
            initServicesDal();
            StartService(_serviceDal);
            Console.ReadLine();
        }
 
 
 
 
        /// <summary>
        /// Adresse IP de l'hôte de services WCF
        /// </summary>
        public static string AdresseIp { get; set; }
        /// <summary>
        /// URL du service WCF
        /// </summary>
        public static string UrlService { get; set; }
        /// <summary>
        /// URL des metadonnées du service WCF
        /// </summary>
        public static string UrlMeta { get; set; }
        /// <summary>
        /// Port TCP des services
        /// </summary>
        public static string PortTcp { get; set; }
        /// <summary>
        /// Port HTTP des services
        /// </summary>
        public static string PortHttp { get; set; }
 
        /// <summary>
        /// Service Bll
        /// </summary>
        static Service _serviceBll = new Service();
 
        /// <summary>
        /// Service dal
        /// </summary>
        static Service _serviceDal = new Service();
 
        /// <summary>
        /// Méthodes qui écrit un message dans la console de la fenêtre
        /// </summary>
        /// <param name="str">message à afficher dans la console</param>
        private static void Append(string str)
        {
            Console.WriteLine(str);
        }
 
        /// <summary>
        /// Initialisation des Ports depuis le fichier de configuration
        /// </summary>
        private static void InitPorts()
        {            
            PortTcp = "8000";
            PortHttp = "9000";
        }
 
 
        /// <summary>
        /// Initialisation des services depuis les informations du fichier de configurations
        /// </summary>
        private static void initServicesBll()
        {
            InitPorts();
 
 
                _serviceBll.ServiceName = "SampleServiceBll";
                _serviceBll.Contrat = "ISampleServiceBll";
                _serviceBll.Namespace = "SampleWCF.BllInterface";
                _serviceBll.PortTcp = PortTcp;
                _serviceBll.PortHttp = PortHttp;                           
        }
 
 
        private static void initServicesDal()
        {
            InitPorts();
 
 
            _serviceDal.ServiceName = "SampleServiceDal";
            _serviceDal.Contrat = "ISampleServiceDal";
            _serviceDal.Namespace = "SampleWCF.DalInterface";
            _serviceDal.PortTcp = PortTcp;
            _serviceDal.PortHttp = PortHttp;
        }
 
 
        /// <summary>
        /// Initialisation des informations concernant l'adresse IP de l'hôte
        /// </summary>
        private static void InitInfoIpAdress()
        {
            //on récupère l'adresse IP du poste sur lequel est éxecuté l'application
            IPHostEntry ips = Dns.GetHostEntry(Dns.GetHostName());
            AdresseIp = ips.AddressList[0].ToString();
 
            //On affiche cette information dans la console et dans la barre de statut de la fenêtre
            string messageAdresseIp = string.Format("Hôte de services WCF connecté sur l'adresse {0}", AdresseIp);
            Append(messageAdresseIp);
            Append(string.Empty);
        }
 
 
 
        /// <summary>
        /// Démarrage d'un service WCF
        /// </summary>
        /// <param name="service">service à démarrer</param>
        private static void StartService(Service service)
        {
 
            //création d'un ServiceHost à partir du type du service passé en paramètre
            ServiceHost host = new ServiceHost(Type.GetType(string.Format("{0}.{1}, {0}", service.Namespace, service.ServiceName)));
 
            //affectation des événement au ServiceHost
            host.Opening += new EventHandler(host_Opening);
            host.Opened += new EventHandler(host_Opened);
            host.Closing += new EventHandler(host_Closing);
            host.Closed += new EventHandler(host_Closed);
 
            //définition de l'URL du service
            service.UrlService = string.Format("net.tcp://{0}:{1}/DivaServices/{2}", AdresseIp, service.PortTcp, service.ServiceName);
            UrlService = service.UrlService;
 
            //Création du NET.TCP Binding pour exposer le service
            NetTcpBinding tcpBinding = new NetTcpBinding();
            tcpBinding.TransactionFlow = false;
            tcpBinding.MaxReceivedMessageSize = 5000000;
            tcpBinding.Security.Transport.ProtectionLevel = System.Net.Security.ProtectionLevel.EncryptAndSign;
            tcpBinding.Security.Transport.ClientCredentialType = TcpClientCredentialType.Windows;
            tcpBinding.Security.Mode = SecurityMode.None;
 
            // On ajoute un endPoint
            host.AddServiceEndpoint(Type.GetType(string.Format("{0}.{1}, {0}", service.Namespace, service.Contrat)), tcpBinding, UrlService);
 
            // Permet de faire remonter les exceptions au client
            ServiceBehaviorAttribute serviceBehavior = (ServiceBehaviorAttribute)host.Description.Behaviors[0];
            serviceBehavior.IncludeExceptionDetailInFaults = true;
 
 
            //Création d'un canal pour décrire le service dans un page HTML (type wsdl des webServices)
            ServiceMetadataBehavior metadataBehavior;
            metadataBehavior = host.Description.Behaviors.Find<ServiceMetadataBehavior>();
            if (metadataBehavior == null)
            {
                metadataBehavior = new ServiceMetadataBehavior();
                metadataBehavior.HttpGetUrl = new Uri(string.Format("http://{0}:{1}/DivaServices/{2}", AdresseIp, service.PortHttp, service.ServiceName));
                metadataBehavior.HttpGetEnabled = true;
                metadataBehavior.ToString();
                host.Description.Behaviors.Add(metadataBehavior);
                service.UrlMeta = metadataBehavior.HttpGetUrl.ToString();
                UrlMeta = service.UrlMeta;
            }
 
            //Ouverture du ServiceHost
            host.Open();
 
        }
 
 
        private static void host_Opening(object sender, EventArgs e)
        {
            Append(string.Format("{0} : Service en connexion ... attendez.", DateTime.Now.ToLongTimeString()));
        }
 
        private static void host_Closed(object sender, EventArgs e)
        {
            ServiceHost host = (ServiceHost)sender;
            Append(string.Format("Service {0} arrêté.", host.Description.Name));
            Append(string.Empty);
        }
 
        private static void host_Closing(object sender, EventArgs e)
        {
            Append(string.Format("{0} : Service en fermeture ... attendez.", DateTime.Now.ToLongTimeString()));
        }
 
        private static void host_Opened(object sender, EventArgs e)
        {
            ServiceHost host = (ServiceHost)sender;
            Append(string.Format("Service {0} ouvert.", host.Description.Name));
            Append("Service URL:\t" + UrlService);
            Append("Meta URL:\t" + UrlMeta);
            Append("");
        }
 
 
 
    }
 
 
class Service
    {
        #region Members
 
        public string ServiceName { get; set; }
        public string Contrat { get; set; }
        public string Namespace { get; set; }
        public string PortTcp { get; set; }
        public string PortHttp { get; set; }
        public string UrlService { get; set; }
        public string UrlMeta { get; set; }
 
        #endregion
 
 
        #region Constructors
 
        public Service()
        {
        }
 
        #endregion

Après je génére les proxy avec svcutil.exe par rapport au wsdl généré, puis voici les classes statiques qui initialisent les clients:

BLL:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
public class ProxysBll
    {
 
        SampleServiceBllClient _proxySampleServiceBll;
 
        public SampleServiceBllClient ProxySampleServiceBll
        {
            get
            {
                if (_proxySampleServiceBll == null)
                {
                    string endPointUrl = "net.tcp://10.120.3.27:8000/DivaServices/SampleServiceBll";
 
                    NetTcpBinding tcpBinding = new NetTcpBinding();
                    tcpBinding.TransactionFlow = false;
                    tcpBinding.Security.Transport.ProtectionLevel = System.Net.Security.ProtectionLevel.EncryptAndSign;
                    tcpBinding.Security.Transport.ClientCredentialType = TcpClientCredentialType.Windows;
                    tcpBinding.Security.Mode = SecurityMode.None;
                    tcpBinding.MaxBufferSize = 5000000;
 
                    EndpointAddress endpointAddress = new EndpointAddress(endPointUrl);
 
                    _proxySampleServiceBll = new SampleServiceBllClient(tcpBinding, endpointAddress);
                }
                return _proxySampleServiceBll;
            }
        }
 
    }

Dal:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
 
public class ProxysDal
    {
 
        SampleServiceDalClient _proxySampleServiceDal;
 
        public SampleServiceDalClient ProxySampleServiceDal
        {
            get
            {
                if (_proxySampleServiceDal == null)
                {
                    string endPointUrl = "net.tcp://10.120.3.27:8000/DivaServices/SampleServiceDal";
 
                    NetTcpBinding tcpBinding = new NetTcpBinding();
                    tcpBinding.TransactionFlow = false;
                    tcpBinding.Security.Transport.ProtectionLevel = System.Net.Security.ProtectionLevel.EncryptAndSign;
                    tcpBinding.Security.Transport.ClientCredentialType = TcpClientCredentialType.Windows;
                    tcpBinding.Security.Mode = SecurityMode.None;
                    tcpBinding.MaxBufferSize = 5000000;
 
                    EndpointAddress endpointAddress = new EndpointAddress(endPointUrl);
 
                    _proxySampleServiceDal = new SampleServiceDalClient(tcpBinding, endpointAddress);                       
                }
                Console.WriteLine("proxy DAL créé, bientôt bon...");
                return _proxySampleServiceDal;
            }
        }
 
    }

17/03/2009, 12h48
Gold Bug

Y'a un truc qui me chiffonne: tes classes ProxysDAL et ProxysBLL indiquent une adresse IP en 10.120.3.27, mais dans le message de ton exception, il cherche un serveur sur une adresse en 127.0.0.1...... :roll: :roll: :roll:
17/03/2009, 13h23
obitskater

Citation:

Envoyé par Gold Bug

Y'a un truc qui me chiffonne: tes classes ProxysDAL et ProxysBLL indiquent une adresse IP en 10.120.3.27, mais dans le message de ton exception, il cherche un serveur sur une adresse en 127.0.0.1...... :roll: :roll: :roll:

Autant pour moi, j'avais recopié le message, depuis mon ancienne config. Mais le message d'exception actuel renvoie bien la bonne ip.
17/03/2009, 13h31
Gold Bug

Dommage
17/03/2009, 17h02
obitskater

YAATAAA !!! (comme dirait un certain japonais manipulateur du temps^^).

J'ai enfin trouvé d'où cela venait...

En fait lorsque l'on utilise une application winforms pour héberger plusieurs services WCF, ils se calent sur le même thread que celui de l'application Winforms.
Il y a donc un conflit, et la solution et de lancer chaque service dans un thread rexpectif.

Citation:

Envoyé par Gold Bug
Si ça peut t'aider

http://www.codeproject.com/KB/WCF/wc...86&msg=1825886

Gold Bug, ton lien a été très utile pour voir à peu près comment mettre en place ceci correctement (cf la partie Hosting the Service)

Et ce qui m'a mis la puce à l'oreille à été ce post trouvé dans les fin-fonds de google, car oui j'avais passé ma vie sur google ces derniers jours :mouarf:
Je vous le donne pour avoir une meilleure explication du problème.
http://bytes.com/groups/net-c/750779...ent-call-hangs

Voilà merci encore à vous deux pour m'avoir aider à mieux cerner mon problème :king:
17/03/2009, 17h10
Bluedeep

Effectivement, je n'avais pas percuté la dessus; il est vrai qu'il est assez peu courant d'hoster un serveur dans une appli Winform.