fcl-web/fr: what changed

Revision 2 to 3. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1		-	~~## Contents~~
2		-
3		-	* 1 Qu'est ce que fpWeb ?
4		-	* 2 Utilisation de fpWeb avec Lazarus
5		-	* 2.1 Installation du paquet Lazarus fpWeb weblaz
6		-	* 2.2 Création d'une application CGI
7		-	* 2.3 Déploiement d'une application CGI
8		-	* 2.4 Formatage du HTML and lecture des champs de requête
9		-	* 2.5 Lecture des données GET
10		-	* 2.6 Lecture des données POST
11		-	* 2.7 Lecture des données binaire POST
12		-	* 3 Modules spécialisés
13		-	* 4 Utiliser de multiples modules
14		-	* 5 Utilisation des actions
15		-	* 6 Utilisation des patrons HTML
16		-	* 7 Conseils & résolution de problèmes
17		-	* 7.1 Envoi des codes de retour
18		-	* 7.2 Envoi de données binaires
19		-	* 7.3 Erreur: "Could not determine HTTP module for request"
20		-	* 7.4 Erreur: "response code 500 Internal Server error when trying to handle DELETE method"
21		-	* 7.5 fpWeb/FCGI et Apache 2.4 (mode mod_proxy_fcgi)
22		-	* 7.6 fpWeb/FCGI et nginx
23		-	* 8 Notes
24		-	* 9 Voir aussi
25		-
26	1		## Qu'est ce que fpWeb ?
27	2
28	3		fpWeb peut être utilisé pour construire des applications Web serveur. Une application serveur Web peut être l'une des suivantes:
29	4
30	5		* Application CGI.
31	6		* Application FastCGI.
32	7		* Module Apache.
33	8		* Serveur HTTP(s) autonome utilisant les composants Free Pascal HTTP server.
34	9		* Serveur HTTP(s) autonome utilisant libmicrohttp de GNU.
35	10		* Application Windows SysHTTP.
36	11
37	12		Dans tous les cas, le modèle de développement est le même : Vous enregistrez des gestionnaires (handlers) pour un ensemble d'URL (appelées routes) auxquels votre application saura répondre. Ensuite vous incorporez ces routes dans l'un des environnements du dessus : Ceci signifie que vous choisissez l'objet application que vous allez utilisez.
38	13
39	14		Dans l'EDI Lazarus, vous avez le choix des applications quand vous commencez un nouveau projet. Il est possible de changer le type d'application une fois que l'application a été démarrée, cela se limite souvent au changement de nom d'une unité dans la clause `uses` du projet.
40	15
41	16		Il est possible de prendre en charge de multiples environnement dans un unique exécutable, au prix de quelques efforts supplémentaires. fpWeb offre aussi du support non conventionnel pour un serveur de base de données REST ou pour des mécanismes JSON RPC 2.0. Ceux-ci sont construits en haut de la structure du dessus. Le [[Brook for Free Pascal/fr\|cadre d'application Brook]] est aussi construit en haut de l'architecture exposée au dessus. Plus d'informations sur le sujet peut être trouvé dans [[fpWeb Tutorial]].
42	17
43	18		## Utilisation de fpWeb avec Lazarus
44	19
45	20		### Installation du paquet Lazarus fpWeb weblaz
46	21
47	22		The first step to do is installing the package which comes in the path lazarus/components/fpweb/weblaz.lpk. As usual with design-time packages, you'll have to rebuild Lazarus.
48	23
49	24		### Création d'une application CGI
50	25
51	26		Après que le paquet `weblaz` ait été installé, une très simple application Web CGI qui affiche une page HTML peut être créée en allant dans le menu Lazarus "Fichier" -> "Nouveau...". Dans la liste des applications possibles, sélectionnez "CGI Application" comme dans l'image ci-dessous, qui va créer un fichier de projet CGI principal et un Web module fpweb.
52	27
53	28		[![New cgi.PNG](/wiki-images/e/ec/New_cgi.PNG)](</File:New_cgi.PNG>)
54	29
55	30		Le TFPWebModule vous permet de manipuler des propriétés et des événements utilisant l'inspecteur d'objet.
56	31
57	32		Pour ajouter du code pour montrer la page, un gestionnaire de requête doit être ajouté. Pour faire ceci, double-cliquer sur la propriété `OnRequest` dans l'inspecteur d'objet, comme dans l'image qui suit:
58	33
59	34		[![Webmodule.PNG](/wiki-images/3/3d/Webmodule.PNG)](</File:Webmodule.PNG>)
60	35
61	36		Dans le gestionnaire d'événement, on doit écrire le code HTML qui sera affiché par le navigateur. Pour éviter de mélanger le Pascal et le HTML, cette page peut être chargée depuis le répertoire où se trouve l'exécutable CGI, en utilisant `AResponse.Contents.LoadFromFile()`.
62	37
63	38		Le type de la réponse doit être défini dans `AResponse.ContentType`. Pour les pages HTML, cela devrait avoir la valeur `'text/html;charset=utf-8'`.
64	39
65	40		Finalement, `Handled` devrait être défini à `True` pour indiquer que la requête a été traité avec succès (et retourne un code d'état '200 OK' au navigateur). Après l'ajout de ce code, le module Web devrait ressembler à ceci :
66	41		```
67	42		unit mainpage;
68	43
69	44		{$mode objfpc}{$H+}
70	45
71	46		interface
72	47
73	48		uses
74	49		Classes, SysUtils, FileUtil, HTTPDefs, websession, fpHTTP, fpWeb;
75	50
76	51		type
77	52
78	53		{ TFPWebModule1 }
79	54
80	55		TFPWebModule1 = class(TFPWebModule)
81	56		procedure DataModuleRequest(Sender: TObject; ARequest: TRequest;
82	57		AResponse: TResponse; var Handled: Boolean);
83	58		private
84	59		{ private declarations }
85	60		public
86	61		{ public declarations }
87	62		end;
88	63
89	64		var
90	65		FPWebModule1: TFPWebModule1;
91	66
92	67		implementation
93	68
94	69		{$R *.lfm}
95	70
96	71		{ TFPWebModule1 }
97	72
98	73		procedure TFPWebModule1.DataModuleRequest(Sender: TObject; ARequest: TRequest;
99	74		AResponse: TResponse; var Handled: Boolean);
100	75		begin
101	76		AResponse.ContentType := 'text/html;charset=utf-8';
102	77		AResponse.Contents.LoadFromFile(ExtractFilePath(ParamStr(0)) + 'mainpage.html');
103	78		Handled := True;
104	79		end;
105	80
106	81		begin
107	82		RegisterHTTPModule('TFPWebModule1', TFPWebModule1);
108	83		end.
109	84		```
110	85
111	86		### Déploiement d'une application CGI
112	87
113	88		Cette section suppose que le serveur Web Apache est utilisé. Bien sûr, d'autres serveurs Web qui supportent CGI (nginx, cherokee) peuvent aussi être utilisé.
114	89
115	90		Apache peut être téléchargé [ici](<http://httpd.apache.org/download.cgi>) ou installé en utilisant le gestionnaire de paquets de votre distribution.
116	91
117	92		L'installation par défaut d'Apache traitera tous les fichiers dans son répertoire cgi-bin comme des programmes CGI, afin que l'utilisateur ne puisse pas accéder aux fichiers HTML simples qui y sont placés. Ce répertoire peut être défini dans le fichier `httpd.conf` dans la section suivante :
118	93		```
119	94		#
120	95		# ScriptAlias: This controls which directories contain server scripts.
121	96		# ScriptAliases are essentially the same as Aliases, except that
122	97		# documents in the target directory are treated as applications and
123	98		# run by the server when requested rather than as documents sent to the
124	99		# client. The same rules about trailing "/" apply to ScriptAlias
125	100		# directives as to Alias.
126	101		#
127	102		ScriptAlias /cgi-bin/ "C:/Program Files/Apache Software Foundation/Apache2.2/cgi-bin/"
128	103		```
129	104
130	105		Si vous placez un exécutable appelé "mywebpage.cgi" dans ce répertoire, alors la page peut être accédée comme `<http://localhost/cgi-bin/mywebpage.cgi>` (ou à distance avec l'adresse IP correspondante ou le nom de domaine).
131	106
132	107		fcl-web avec Lazarus sur Windows produit des fichiers .exe. Pour qu'Apache serve ces fichiers, vous devez ajouter ceci:
133	108		```
134	109		AddHandler cgi-script .exe
135	110		```
136	111
137	112		Et pour servir vos exécutables depuis un autre répertoire, vous ajoutez ceci :
138	113		```
139	114		ScriptAlias /bin/ "C:/lazarus_projects/test-fclweb/bin/"
140	115		<Directory "C:/lazarus_projects/test-fclweb/bin/">
141	116		AllowOverride None
142	117		Options None
143	118		Order allow,deny
144	119		Allow from all
145	120		</Directory>
146	121		```
147	122
148	123		### Formatage du HTML and lecture des champs de requête
149	124
150	125		L'exemple précédent montrait juste une simple page HTML. On pourrait désirer p.ex. :
151	126
152	127		* changer dynamiquement la sortie de la page HTML, et
153	128		* en lisant les variables que le navigateur a transmises à la page Web dans les champs de requête (par exemple dans les actions HTTP GET et HTTP POST).
154	129
155	130		Une solution simple pour le premier problème est l'utilisation de routine de format du Pascal standard et l'ajout des `%s` ou `%d` dans le fichier HTML aux places appropriées qui recevront les valeurs spécifiques.
156	131
157	132		### Lecture des données GET
158	133
159	134		Pour lire les variables GET, on peut utiliser `ARequest.QueryFields`, qui est un descendant de TStrings. Chaque variable sera dans une ligne séparée de la TStrings selon le format NomVariable=Valeur, de la même façon qu'elles sont montrées dans l'adresse de la page du navigateur. Pour accéder à une variable, on utilise `ARequest.QueryFields.Values[]` en passant le nom de la variable dans les crochets pour recevoir en retour sa valeur, au lieu d'analyser la chaîne manuellement (NdT: Explication superflue, classe de base du Pascal Objet).
160	135
161	136		Le code résultant :
162	137		```
163	138		procedure TFPWebModule1.DataModuleRequest(Sender: TObject; ARequest: TRequest;
164	139		AResponse: TResponse; var Handled: Boolean);
165	140		var
166	141		HexText, AsciiText: string;
167	142		begin
168	143		HexText := ARequest.QueryFields.Values['hex'];
169	144		AsciiText := HexToAnsii(HexText);
170	145
171	146		AResponse.ContentType := 'text/html;charset=utf-8';
172	147		AResponse.Contents.LoadFromFile(ExtractFilePath(ParamStr(0)) + 'mainpage.html');
173	148		AResponse.Contents.Text := Format(AResponse.Contents.Text,
174	149		[HexText, AsciiText]);
175	150		Handled := True;
176	151		end;
177	152		```
178	153
179	154		### Lecture des données POST
180	155
181	156		Les données soumises par des requêtes POST peuvent être obtenues de `TRequest.Content`. Il viendra sans les entêtes de requête - en d'autres mots, il contient le corps de la requête.
182	157
183	158		Les données de formulaire soumises peuvent être accédées en utilisant `TRequest.ContentFields` qui est le contenu analysé comme des champs séparés par & et décodés. Par exemple, l'ensemble suivant de valeurs de formulaire :
184	159		```
185	160		login: dfg 345&&
186	161		login_senha: ====
187	162		email: dfg
188	163		```
189	164
190	165		Sera décodé en 'APPLICATION/X-WWW-FORM-URLENCODED' comme ceci (voir [wikipedia POST (HTTP)](<http://en.wikipedia.org/wiki/POST_%28HTTP%29>)):
191	166		```
192	167		login=dfg+345%26%26&login_senha=%3D%3D%3D%3D&email=dfg
193	168		```
194	169
195	170		Et sera disponible dans `TRequest.ContentFields` via l'index de ligne ou en utilisant la propriété `Values`, ce qui est plus pertinent :
196	171		```
197	172		TRequest.ContentFields[0]: login=dfg 345&&
198	173		TRequest.ContentFields[1]: login_senha=====
199	174		TRequest.ContentFields[2]: email=dfg
200	175		TRequest.ContentFields.Values['email']: dfg
201	176		```
202	177
203	178		En cas d'utilisation d'autres types MIME que 'MULTIPART/FORM-DATA' et 'APPLICATION/X-WWW-FORM-URLENCODED' (les types supportés par les formulaires HTML) :
204	179
205	180		* le contenu est uniquement disponible dans `TRequest.Content` et non pas `TRequest.ContentFields`.
206	181		* l'usage de ces types MIME lève un exception pour FPC 2.4.2 (corrigé dans FPC 2.5+).
207	182
208	183		Remarquez que HTTP POST peut aussi envoyer des champs de requête (dans l'URL), p.ex. `<http://server/bla?question=how>`, et qui sont accédés par `TRequest.QueryFields` comme expliqué dans la section précédente.
209	184		```
210	185		procedure TFPWebModule1.DataModuleRequest(Sender: TObject; ARequest: TRequest;
211	186		AResponse: TResponse; var Handled: Boolean);
212	187		var
213	188		lData: String;
214	189		begin
215	190		lData := ARequest.Content;
216	191		```
217	192
218	193		### Lecture des données binaire POST
219	194
220	195		Les fichiers téléchargés vers le serveur sont sauvés dans un emplacement temporaire avec un nom de fichier temporaire, pour conserver le fichier, vous devrez le déplacer vers un emplacement permanent.
221	196
222	197		Pour recevoir des données sur le serveur qui a été POSTé p.ex comme multipart/form-data, utilisez quelques chose comme ceci :
223	198		```
224	199		procedure TMainWebModule.TFPWebActions2Request(Sender: TObject;
225	200		ARequest: TRequest; AResponse: TResponse; var Handled: Boolean);
226	201		var
227	202		i: Integer;
228	203		begin
229	204		// Process all received files
230	205		for i := 0 to ARequest.Files.Count - 1 do
231	206		begin
232	207		// Doing something else than writeln is highly recommended ;)
233	208		writeln ('Received Filename: '+ARequest.Files[i].LocalFileName);
234	209		end;
235	210
236	211		Handled := true;
237	212		end;
238	213		```
239	214
240	215		Le client peut envoyer des données en utilisant p.ex. `FileFormPost`.
241	216
242	217		## Modules spécialisés
243	218
244	219		La classe `TFPWebModule` (utilisée dessous) est un simple exemple de module Web quii peut être utilisé pour toutes sortes de requêtes HTTP..
245	220
246	221		Toutefois, fpweb vient avec quelques modules spécialisés, qui réalisent des tâches spécialisés :
247	222
248	223		* La classe TSimpleFileModule dans l'unité _fpwebfile.pp_ peut etre utilisée pour envoyer des fichiers. Vous pointez vers un répertoire et elle fait le reste.
249	224		* La classe TFPHTMLModule dans l'unité _fphtml.pp_ peut être utlisé pour produire du HTML.
250	225		* La classe TProxyWebModule dans l'unité _fpwebproxy.pp_ est un proxy de transmission (forwarding proxy) prêt à l'emploi.
251	226		* La classe TFPWebProviderDataModule dans l'unité _fpwebdata.pp_ sert des données au format JSON qui peut être consommé par des magasins (stores) ExtJS.
252	227		* La classe TSQLDBRestModule dans l'unité _sqldbrestmodule.pp_ implémente un serveur full REST appuyé par SQLDB. Voir plus d'informations dans [[SQLDBRestBridge]].
253	228		* La classe TJSONRPCModule dans l'unité _webjsonrpc.pp_ implémente un service JSON-RPC.
254	229		* La classe TExtDirectModule dans l'unité _fpextdirect.pp_ implémente une variante Ext.Direct d'un service JSON-RPC.
255	230
256	231		## Utiliser de multiples modules
257	232
258	233		Si il y a un seul module dans l'application Web, toutes les requêtes seront redirigées vers ce module.
259	234
260	235		Comme votre application Web grossit, de multiples modules peuvent être utilisés. Un nouveau module peut être ajouté en choisissant "Fichier" -> "Nouveau..." et ensuite un des 'Module Web' ou 'Module Web HTML'.
261	236
262	237		FCL-web utilise l'URL pour déterminer comment une requête HTTP qui devrait être manipulé. Il doit donc savoir quels modules Web existent dans l'application. Pour ce faire, chaque module doit être enregistré.
263	238
264	239		Chaque module est enregistré avec fcl-web dans la section 'initialisation de l'unité dans lequel il est défini:
265	240		```
266	241		RegisterHTTPModule('location', TMyModule);
267	242		```
268	243
269	244		Le module sera alors invoqué si une URL de la forme
270	245		```
271	246		http://www.mysite.org/mycgi.cgi/location
272	247		```
273	248
274	249		ou
275	250		```
276	251		http://www.mysite.org/mycgi.cgi?module=location
277	252		```
278	253
279	254		est utilisée.
280	255
281	256		Si plusieurs modules sont présents, le nom du module doit apparaître dans l'URL, ou une erreur sera levée.
282	257
283	258		Ce comportement peut aussi être forcé pour les applications qui ont seulement un unique module en définissant la propriéte `AllowDefaultModule` de l'application à `False` :
284	259		```
285	260		Application.AllowDefaultModule := False;
286	261		```
287	262
288	263		Dans ce cas, l'application fcl-web requerra toujours le nom du module dans l'URL.
289	264
290	265		Le nom de la variable de requête qui détermine le nom du module (par défaut, c'est 'module') peut être défini dans la propriété `Application.ModuleVariable`. Le code suivant
291	266		```
292	267		Application.ModuleVariable := 'm';
293	268		```
294	269
295	270		assure que l'URL suivante est dirigée vers `TMyModule` :
296	271		```
297	272		http://www.mysite.org/mycgi.cgi?m=location
298	273		```
299	274
300	275		Si tout ceci n'est pas suffisant pour déterminer le module vers lequel la requête devrait être passée, l'événement `Application.OnGetModule` peut être utilisé. Il est du type `TGetModuleEvent` :
301	276		```
302	277		type
303	278		TGetModuleEvent = Procedure (Sender : TObject; ARequest : TRequest;
304	279		Var ModuleClass : TCustomHTTPModuleClass) of object;
305	280		```
306	281
307	282		La création d'un gestionnaire pour cet événement permet un contrôle fin sur le module qui est créé pour manipuler la requête : la requête (passée dans `ARequest`) peut être examinée et la variable `ModuleClass` doit être définie par la classe du module qui devrait manipuler la requête.
308	283
309	284		Si `ModuleClass` vaut `Nil` au retour, une erreur sera envoyée au navigateur.
310	285
311	286		## Utilisation des actions
312	287
313	288		Un module peut être utilisé pour grouper certaines sortes d'actions logiquement liées. Imaginez un module `TUserModule` qui est utilisé pour traiter la gestion utilisateur dans les pages Web. Il peut y avoir de multiples actions associées avec un utilisateur :
314	289
315	290		* Création
316	291		* Suppression
317	292		* Mise à jour
318	293		* Affichage
319	294
320	295		Ces différentes actions peuvent être maniée par le mêm module. On peut déterminer l'action depuis l'URL manuellement, comme dans :
321	296		```
322	297		http://mysite/mycgi.cgi/user?action=delete&id=12
323	298		```
324	299
325	300		Cela peut être automatisé.
326	301
327	302		Afin de rendre plus facile la distinction entre les diverses actions, le module a une propriété `actions` : c'est une collection, dans laquelle chaque article est associé avec une réponse différente à la requête. Les actions ont diverses propriétés :
328	303
329		-	~~`Name`~~
330		-	~~Le nom de l'action. L'URL sera examinée pour déterminer le nom de l'action.~~
331		-	~~`Content`~~
332		-	~~Une chaîne de caractères. Si définie, c'est envoyé vers le navigateur.~~
333		-	~~`Contents`~~
334		-	~~Une TStringList. c'est envoyé vers le navigateur.~~
335		-	~~`ContentProducer`~~
336		-	~~Si définie, the ContentProducer maniera la requête.~~
337		-	~~`Default`~~
338		-	~~Si définie à `True`, alors cette action est l'action par défaut. Ceci signifie que si FCL-Web ne peut pas déterminer le nom de l'action, cette action sera exécutée.~~
339		-	~~`Template`~~
340		-	~~Si définie, ce patron sera traité et les résultats envoyés vers le navigateur.~~
	304	+	`Name`
341	305
	306	+	Le nom de l'action. L'URL sera examinée pour déterminer le nom de l'action.
	307	+
	308	+	`Content`
	309	+
	310	+	Une chaîne de caractères. Si définie, c'est envoyé vers le navigateur.
	311	+
	312	+	`Contents`
	313	+
	314	+	Une TStringList. c'est envoyé vers le navigateur.
	315	+
	316	+	`ContentProducer`
	317	+
	318	+	Si définie, the ContentProducer maniera la requête.
	319	+
	320	+	`Default`
	321	+
	322	+	Si définie à `True`, alors cette action est l'action par défaut. Ceci signifie que si FCL-Web ne peut pas déterminer le nom de l'action, cette action sera exécutée.
	323	+
	324	+	`Template`
	325	+
	326	+	Si définie, ce patron sera traité et les résultats envoyés vers le navigateur.
	327	+
342	328		Il y a aussi quelques événements :
343	329
344		-	~~`BeforeRequest`~~
345		-	~~exécuté avant que la requête ne soit traitée. Peut être utilisé pour définir le 'Content' ou d'autres propriétés.~~
346		-	~~`AfterRequest`~~
347		-	~~exécuté après le traitement de la requête.~~
348		-	~~`OnRequest`~~
349		-	~~un gestionnaire d'événement pour manier la requête. Si défini, le gstionnaire est utilisé pour manier la requête.~~
	330	+	`BeforeRequest`
	331	+
	332	+	exécuté avant que la requête ne soit traitée. Peut être utilisé pour définir le 'Content' ou d'autres propriétés.
	333	+
	334	+	`AfterRequest`
	335	+
	336	+	exécuté après le traitement de la requête.
	337	+
	338	+	`OnRequest`
	339	+
	340	+	un gestionnaire d'événement pour manier la requête. Si défini, le gstionnaire est utilisé pour manier la requête.
350	341
351	342		Encore une fois, comme dans le cas de plusieurs modules, l'URL est utilisée pour déterminer quelle action exécuter. La partie juste après la partie module ("utilisateur" dans cet exemple) est utilisée:
352	343		```
353	344		http://mysite/mycgi.cgi/user/delete&id=12
354	345		```
355	346
356	347		exécutera l'action nommée 'delete'.
357	348
358	349		La propriété `ActionVar` du module peut être utilisée pour définir le nom de la variable de requête à utiliser. En affectant :
359	350		```
360	351		UserModule.ActionVar := 'a';
361	352		```
362	353
363	354		peut être utilisé pour changer l'URL du dessus en :
364	355		```
365	356		http://mysite/mycgi.cgi/user?a=delete&id=12
366	357		```
367	358
368	359		S'il y a seulement un module dans l'application, l'URL peut être raccourci en :
369	360		```
370	361		http://mysite/mycgi.cgi/delete&id=12
371	362		```
372	363
373	364		## Utilisation des patrons HTML
374	365
375	366		Pour de l'information au sujet des patrons (template), des étiquettes de patron (template tags) et des paramètres d'étiquettes de patron (template tag parameters) pour générer les pages de réponse, veuillez vous référer au fichier `fptemplate.txt` dans le répertoire FPC dans `/packages/fcl-base/texts/` (NdT : spécifique Linux)
376	367
377	368		Des projets d'exemple qui démontrent l'utilisation des patrons peuvent être trouvés sous le répertoire FPC dans `/packages/fcl-web/examples/fptemplate` (voir le README.txt dedans pour plus).
378	369
379	370		(Dans les versions antérieures, ces exemples se trouvaient dans le répertoire Lazarus dans `/components/fpweb/demo/fptemplate/`)
380	371
381	372		## Conseils & résolution de problèmes
382	373
383	374		### Envoi des codes de retour
384	375
385	376		Pour envoyer une réponse HTTP différente de 200 OK, utiliser `AResponse.Code` et `AResponse.CodeText`, p.ex. :
386	377		```
387	378		AResponse.Code := 404;
388	379		AResponse.CodeText := 'Document not found';
389	380		```
390	381
391	382		### Envoi de données binaires
392	383
393	384		Une approche qui semble marcher pour envoyer p.ex. un fichier tiff depuis le serveur Web vers le client - adapté de `$(fpcdirectory)\packages\fcl-web\examples\jsonrpc\demo1\wmdemo.pp` \- quelque chose comme ceci :
394	385		```
395	386		AResponse.ContentStream := TMemoryStream.Create;
396	387
397	388		try
398	389		AResponse.ContentStream.LoadFromFile('/tmp/sample.tiff');
399	390		AResponse.ContentType := 'image/tiff'; //or whatever MIME type you want to send
400	391		// to do: there is an fpweb example that gets the mime type from the file extension...
401	392		AResponse.ContentLength:=AResponse.ContentStream.Size; //apparently doesn't happen automatically?
402	393		AResponse.SendContent;
403	394		finally
404	395		AResponse.ContentStream.Free;
405	396		end;
406	397
407	398		Handled := true;
408	399		```
409	400
410	401		### Erreur: "Could not determine HTTP module for request"
411	402
412	403		Vous pouvez avoir de multiples modules et de multiples actions. Si vous spécifiez une URL avec un seul item, comme :
413	404		```
414	405		http://localhost/cgi-bin/somemodule
415	406		```
416	407
417	408		alors fpweb suppose que vous êtes en train de spécifier une action. Si vous n'avez pas défini un module par défaut, vous obtiendrez une "500 internal server error (Could not determine HTTP module for request)".
418	409
419	410		Vous pouvez modifier ce comportement pour permettre à fpweb de correspondre à un nom de module à la place en définissant la propriété `PreferModuleName` de l'application sur `True`.
420	411
421	412		### Erreur: "response code 500 Internal Server error when trying to handle DELETE method"
422	413
423	414		Dans FPC 2.6.2 et antérieur, fcl-web n'accepte pas la méthode DELETE et génère une erreur.
424	415
425	416		### fpWeb/FCGI et Apache 2.4 (mode mod_proxy_fcgi)
426	417
427	418		Quand vous voulez déployer une application FastCGI derrière un proxy inverse Apache 2.4+, vous avez besoin de la variable PATH_INFO dans les entêtes qui sont envoyés vai une socket au démon FastCGI.
428	419
429	420		1, Activer les modules suivants: setenvif_module, proxy_module et proxy_fcgi_module
430	421
431	422		(sur CentOS 7 modules sont définis dans le fichier `/etc/httpd/conf.modules.d/00-base.conf` et `/etc/httpd/conf.modules.d/00-proxy.conf)`.
432	423		```
433	424		LoadModule setenvif_module modules/mod_setenvif.so
434	425		LoadModule proxy_module modules/mod_proxy.so
435	426		LoadModule proxy_fcgi_module modules/mod_proxy_fcgi.so
436	427		```
437	428
438	429		2, Configuration du proxy inverse pour fpWeb/FCGI écoutant sur le port 9000.
439	430		$1 = module name
440	431		$2 = action name
441	432		```
442	433		SetEnvIf Request_URI . proxy-fcgi-pathinfo=full
443	434		ProxyPassMatch "/fcgi/(.)/(.)" "fcgi://127.0.0.1:9000/$1/$2"
444	435		```
445	436
446	437		### fpWeb/FCGI et nginx
447	438
448	439		Pour un routage correct, fcl-web requiert que la variable PATH_INFO dans les entêtes envoyés depuis nginx. Pour cela, vous devez diviser l'URL entière en nom d'application FastCGI et en partie information de chemin (path info) avec l'instruction de configuration _fastcgi_split_path_info_. L'instruction accepte une expression régulière et pose la seconde correspondance dans la variable de configuration _$fastcgi_path_info_. Cette variable peut être passée à votre application avec l'instruction _fastcgi_param_.
449	440
450	441		L'exemple de configuration suivante inclut un hôte virtuel complet pour nginx qui passe tout depuis _<http://myserver:8080/mycgiapp/>_ vers une application FastCGI externe.
451	442		```
452	443		server {
453	444
454	445		listen 8080;
455	446		listen [::]:8080;
456	447
457	448		server_name _;
458	449
459	450		root "/var/www";
460	451
461	452		location /mycgiap/ {
462	453		# setting up PATH_INFO
463	454		fastcgi_split_path_info ^(/mycgiapp/)(.*)$;
464	455		fastcgi_param PATH_INFO $fastcgi_path_info;
465	456
466	457		# other parameters
467	458		fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
468	459		fastcgi_param QUERY_STRING $query_string;
469	460		fastcgi_param REQUEST_METHOD $request_method;
470	461		fastcgi_param CONTENT_TYPE $content_type;
471	462		fastcgi_param CONTENT_LENGTH $content_length;
472	463		fastcgi_param SCRIPT_NAME $fastcgi_script_name;
473	464		fastcgi_param REQUEST_URI $request_uri;
474	465		fastcgi_param DOCUMENT_URI $document_uri;
475	466		fastcgi_param DOCUMENT_ROOT $document_root;
476	467		fastcgi_param SERVER_PROTOCOL $server_protocol;
477	468		fastcgi_param REQUEST_SCHEME $scheme;
478	469		fastcgi_param HTTPS $https if_not_empty;
479	470		fastcgi_param GATEWAY_INTERFACE CGI/1.1;
480	471		fastcgi_param SERVER_SOFTWARE nginx/$nginx_version;
481	472		fastcgi_param REMOTE_ADDR $remote_addr;
482	473		fastcgi_param REMOTE_PORT $remote_port;
483	474		fastcgi_param SERVER_ADDR $server_addr;
484	475		fastcgi_param SERVER_PORT $server_port;
485	476		fastcgi_param SERVER_NAME $server_name;
486	477
487	478		# pass requests to your FastCGI application
488	479		fastcgi_pass 127.0.0.1:9000;
489	480		}
490	481		}
491	482		```
492	483
493	484		## Notes
494	485
495	486		* L'unité cgiapp est dépréciée, veuillez utiliser fpcgi autant que possible.
496	487		* Les unités fastcgi, custfcgi et fpfcgi ne sont pas supportées sur Darwin en ce moment (Ndt: Qu'en est-il en 2020 ?), parce qu'il utilise un mécanisme qui différe de l'option MSG_NOSIGNAL pour recv() pour indiquer qu'aucun SIGPIPE ne doit être levé en cas de rupture de la connexion. Voir <http://lists.apple.com/archives/macnetworkprog/2002/Dec/msg00091.html> pour comment cela peut être fixé.
497	488		* Si vous déployez votre application et obtenez des erreurs comme "Error: No action name and no default action", vous devrez vous assurer qu'il y a une action affectée à l'URL, ou intercepter les actions non supportées avec une action marquée Default. Dans les deux cas, un gestionnaire d'événement `OnRequest` pour l'action qui définit `Handled:=true` devrait être utilisé.
498	489
499	490		## Voir aussi
500	491
501	492		* [[fpWeb Tutorial]]
502	493		* [[fphttpclient]] Partie de fcl-web qui peut être utilisé de manière autonome dans des applications clientes.
503	494		* _write me!_ fphttpserver Petit serveur Web autonome en Pascal Objet. Peut être utilisé pour servir des applications CGI fcl-web.
504	495		* [[CGI Web Programming/fr\|Débogage de CGI]] Information concernant le débogage des applications CGI.
505	496		* [Part of a tutorial by Leonardo Ramé that shows how to program an fcl-web CGI application; includes example of generating JSON content](<https://github.com/leonardorame/Ext4-MVC-Tutorial/wiki/Lazarus-Server>)
506	497
507	498		---
508	499		From the Free Pascal wiki, page "fcl-web/fr", as the Internet Archive kept it on 2025-01-22, last changed on 2020-05-01. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history