Skip to content
Newer
Older
100644 500 lines (338 sloc) 13.6 KB
30917ff @miyagawa POD fixes
miyagawa authored
1 =encoding utf-8
2
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
3 =head1 NAME
4
5 PSGI - Perl Web Server Gateway Interface Specification
6
7 =head1 ABSTRACT
8
ff0e6de @miyagawa paragraphized
miyagawa authored
9 This document specifies a standard interface between web servers and
10 Perl web applications or frameworks, to promote web application
11 portability and reduce the duplicated efforts by web application
12 framework developers.
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
13
0f6003f @miyagawa Added a note that PSGI is not an API for end users
miyagawa authored
14 Keep in mind that PSGI is not Yet Another web application
15 framework. PSGI is a specification to decouple web server environments
65afea5 @miyagawa apply grammer fixes from hanekomu
miyagawa authored
16 from web application framework code. PSGI is also not the web
0f6003f @miyagawa Added a note that PSGI is not an API for end users
miyagawa authored
17 application API. Web application developers (end users) are not
65afea5 @miyagawa apply grammer fixes from hanekomu
miyagawa authored
18 supposed to run their web applications directly using the PSGI
19 interface, but instead are encouraged to use frameworks that
20 support PSGI, or use the helper implementations like Plack (more on
21 that later).
0f6003f @miyagawa Added a note that PSGI is not an API for end users
miyagawa authored
22
1173dc0 @miyagawa New spec: feedbacks got merged.
miyagawa authored
23 =head1 TERMINOLOGIES
24
25 =over 4
26
27 =item Servers
28
a19c5ba @miyagawa minor grammer fixes
miyagawa authored
29 Servers are web servers that accept HTTP requests, dispatch the
1173dc0 @miyagawa New spec: feedbacks got merged.
miyagawa authored
30 requests to the web appilcations and return the HTTP response to the
31 clients. In PSGI specification it's a Perl process that's running
a19c5ba @miyagawa minor grammer fixes
miyagawa authored
32 inside an HTTP server (e.g. mod_perl in Apache), a daemon process
1173dc0 @miyagawa New spec: feedbacks got merged.
miyagawa authored
33 called from a web server (e.g. FastCGI daemon) or a pure perl HTTP
34 server.
35
a19c5ba @miyagawa minor grammer fixes
miyagawa authored
36 Servers are also called I<PSGI implementations> as well as
1173dc0 @miyagawa New spec: feedbacks got merged.
miyagawa authored
37 I<Backends>.
38
39 =item Applications
40
a19c5ba @miyagawa minor grammer fixes
miyagawa authored
41 Applications are web applications that actually get HTTP requests
42 and return HTTP response. In PSGI it's a code reference: see below.
1173dc0 @miyagawa New spec: feedbacks got merged.
miyagawa authored
43
44 =item Middleware
45
46 Middleware is a PSGI application, which is a code reference, but also
47 runs like a server to run other applications. It can be thought of a
48 I<plugin> to extend PSGI application: see below.
49
50 =item Framework developers
51
a19c5ba @miyagawa minor grammer fixes
miyagawa authored
52 Framework developers are authors of web application frameworks. They
53 need to write adapters (or engines) to read PSGI input, then run the
54 application logic and returns PSGI response to the server.
1173dc0 @miyagawa New spec: feedbacks got merged.
miyagawa authored
55
56 =item Web application developers
57
58 Web application developers are developers who write code that uses one
59 of the web application framework that uses PSGI interface. They
a19c5ba @miyagawa minor grammer fixes
miyagawa authored
60 usually don't need to deal with nor care about PSGI protocol at all.
1173dc0 @miyagawa New spec: feedbacks got merged.
miyagawa authored
61
30917ff @miyagawa POD fixes
miyagawa authored
62 =back
1173dc0 @miyagawa New spec: feedbacks got merged.
miyagawa authored
63
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
64 =head1 SPECIFICATION
65
66 =head2 Applications
67
ff0e6de @miyagawa paragraphized
miyagawa authored
68 A PSGI application is a Perl code reference. It takes exactly one
69 argument, the environment and returns an array reference of exactly
70 three values.
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
71
72 sub app {
73 my $env = shift;
74 return [
75 '200',
76 [ 'Content-Type' => 'text/plain' ],
31bd78b @miyagawa s/objects/object/ because it sounded like an array of IO::Handle objects
miyagawa authored
77 [ "Hello World" ], # or IO::Handle-like object
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
78 ];
79 }
80
81 =head3 The Environment
82
ff0e6de @miyagawa paragraphized
miyagawa authored
83 The environment MUST be a hash reference that includes CGI-like
84 headers. The application is free to modify the environment. The
85 environment is required to include these variables (adopted from
86 PEP333, Rack and JSGI) except when they'd be empty, but see below:
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
87
88 =over 4
89
90 =item *
91
ff0e6de @miyagawa paragraphized
miyagawa authored
92 C<REQUEST_METHOD>: The HTTP request method, such as "GET" or
93 "POST". This cannot ever be an empty string, and so is always
94 required.
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
95
96 =item *
97
ff0e6de @miyagawa paragraphized
miyagawa authored
98 C<SCRIPT_NAME>: The initial portion of the request URL's I<path> that
99 corresponds to the application, so that the application knows its
65afea5 @miyagawa apply grammer fixes from hanekomu
miyagawa authored
100 virtual "location". This may be an empty string if the application
ff0e6de @miyagawa paragraphized
miyagawa authored
101 corresponds to the "root" of the server.
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
102
103 =item *
104
ff0e6de @miyagawa paragraphized
miyagawa authored
105 C<PATH_INFO>: The remainder of the request URL's "path", designating
106 the virtual "location" of the request's target within the
65afea5 @miyagawa apply grammer fixes from hanekomu
miyagawa authored
107 application. This may be an empty string if the request URL targets
ff0e6de @miyagawa paragraphized
miyagawa authored
108 the application root and does not have a trailing slash. This value
b2f90a3 @miyagawa PATH_INFO should be decoded by servers
miyagawa authored
109 should be URI decoded by servers to be compatible to RFC 3875.
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
110
111 =item *
112
ff0e6de @miyagawa paragraphized
miyagawa authored
113 C<QUERY_STRING>: The portion of the request URL that follows the C<?>,
114 if any. May be empty, but is always required.
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
115
116 =item *
117
ff0e6de @miyagawa paragraphized
miyagawa authored
118 C<SERVER_NAME>, C<SERVER_PORT>: When combined with C<SCRIPT_NAME> and
119 C<PATH_INFO>, these variables can be used to complete the URL. Note,
120 however, that C<HTTP_HOST>, if present, should be used in preference
121 to C<SERVER_NAME> for reconstructing the request URL. C<SERVER_NAME>
122 and C<SERVER_PORT> can never be empty strings, and so are always
123 required.
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
124
125 =item *
126
ff0e6de @miyagawa paragraphized
miyagawa authored
127 C<SERVER_PROTOCOL>: The version of the protocol the client used to
128 send the request. Typically this will be something like "HTTP/1.0" or
129 "HTTP/1.1" and may be used by the application to determine how to
130 treat any HTTP request headers.
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
131
132 =item *
133
ff0e6de @miyagawa paragraphized
miyagawa authored
134 C<HTTP_> Variables: Variables corresponding to the client-supplied
135 HTTP request headers (i.e., variables whose names begin with
136 C<HTTP_>). The presence or absence of these variables should
65afea5 @miyagawa apply grammer fixes from hanekomu
miyagawa authored
137 correspond to the presence or absence of the appropriate HTTP header
ff0e6de @miyagawa paragraphized
miyagawa authored
138 in the request.
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
139
1173dc0 @miyagawa New spec: feedbacks got merged.
miyagawa authored
140 If there are multiple header lines sent with the same key, the server
141 should treat them as if they're sent in one line, i.e. combine them
142 with C<, > as in RFC 2616.
143
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
144 =back
145
ff0e6de @miyagawa paragraphized
miyagawa authored
146 In addition to this, the PSGI environment MUST include these
147 PSGI-specific variables:
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
148
149 =over 4
150
151 =item *
152
153 C<psgi.version>: An array ref [1,0] representing this version of PSGI.
154
155 =item *
156
157 C<psgi.url_scheme>: A string C<http> or C<https>, depending on the request URL.
158
159 =item *
160
65afea5 @miyagawa apply grammer fixes from hanekomu
miyagawa authored
161 C<psgi.input>: the input stream. See below.
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
162
163 =item *
164
165 C<psgi.errors>: the error stream. See below.
166
eee7655 @miyagawa Added psgi.multithread and psgi.multiprocess per discussion on about …
miyagawa authored
167 =item *
168
169 C<psgi.multithread>: true if the application may be simultaneously
170 invoked by another thread in the same process, false otherwise.
171
172 =item *
173
174 C<psgi.multiprocess>: true if an equivalent application object may be
175 simultaneously invoked by another process, false otherwise.
176
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
177 =back
178
179 The PSGI environment MAY include these optional PSGI variables:
180
181 =over 4
182
183 =item *
184
ff0e6de @miyagawa paragraphized
miyagawa authored
185 C<psgi.run_once>: true if the server expects (but does not guarantee!)
186 that the application will only be invoked this one time during the
187 life of its containing process. Normally, this will only be true for a
188 server based on CGI (or something similar).
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
189
190 =item *
191
e21be68 @miyagawa s/.async/.nonblocking/ per discussions with nothingmuch++
miyagawa authored
192 C<psgi.nonblocking>: true if the server is calling the application in an
193 non-blocking event loop.
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
194
195 =back
196
65afea5 @miyagawa apply grammer fixes from hanekomu
miyagawa authored
197 The server or the application can store its own data in the
ff0e6de @miyagawa paragraphized
miyagawa authored
198 environment, too. The keys MUST contain at least one dot, and should
199 be prefixed uniquely. The prefix C<psgi.> is reserved for use with the
200 PSGI core implementation and other accepted extensions and MUST NOT be
201 used otherwise. The environment MUST NOT contain the keys
202 C<HTTP_CONTENT_TYPE> or C<HTTP_CONTENT_LENGTH> (use the versions
203 without C<HTTP_>). The CGI keys (named without a period) MUST have a
204 scalar variable containing strings. There are the following
205 restrictions:
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
206
207 =over 4
208
209 =item *
210
211 C<psgi.version> MUST be an array of integers.
212
213 =item *
214
65afea5 @miyagawa apply grammer fixes from hanekomu
miyagawa authored
215 C<psgi.url_scheme> MUST be a scalar variable containing either the
ff0e6de @miyagawa paragraphized
miyagawa authored
216 string C<http> or C<https>.
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
217
218 =item *
219
220 There MUST be a valid input stream in C<psgi.input>.
221
222 =item *
223
224 There MUST be a valid error stream in C<psgi.errors>.
225
226 =item *
227
228 The C<REQUEST_METHOD> MUST be a valid token.
229
230 =item *
231
232 The C<SCRIPT_NAME>, if non-empty, MUST start with C</>
233
234 =item *
235
236 The C<PATH_INFO>, if non-empty, MUST start with C</>
237
238 =item *
239
240 The C<CONTENT_LENGTH>, if given, MUST consist of digits only.
241
242 =item *
243
ff0e6de @miyagawa paragraphized
miyagawa authored
244 One of C<SCRIPT_NAME> or C<PATH_INFO> MUST be set. C<PATH_INFO> should
65afea5 @miyagawa apply grammer fixes from hanekomu
miyagawa authored
245 be C</> if C<SCRIPT_NAME> is empty. C<SCRIPT_NAME> should never be C</>,
246 but should instead be empty.
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
247
248 =back
249
250 =head3 The Input Stream
251
ff0e6de @miyagawa paragraphized
miyagawa authored
252 The input stream in C<psgi.input> is an IO::Handle-like object which
253 streams the raw HTTP POST or PUT data. If it is a file handle then it
254 MUST be opened in binary mode. The input stream MUST respond to
255 C<read> and MAY implement C<seek>.
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
256
ff0e6de @miyagawa paragraphized
miyagawa authored
257 The built-in filehandle or IO::Handle based objects should work fine
258 everywhere. Application developers SHOULD NOT inspect the type or
259 class of the stream, but instead just call C<read> to duck type.
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
260
e764e4f @miyagawa Added a note about read() built-in
miyagawa authored
261 Application developers SHOULD NOT use the built-in C<read> function to
262 read from the input stream, because C<read> function only works with
65afea5 @miyagawa apply grammer fixes from hanekomu
miyagawa authored
263 the real IO object (a glob ref based file handle or PerlIO) and makes
264 duck typing difficult. Web application framework developers, if
265 they know the input stream will be used with the built-in read() in any
d36f900 @miyagawa web framework should deal with this IO thing
miyagawa authored
266 upstream code they can't touch, SHOULD use PerlIO or tie handle to
267 work around with this problem.
e764e4f @miyagawa Added a note about read() built-in
miyagawa authored
268
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
269 =over 4
270
271 =item read
272
273 $input->read($buf, $len [, $offset ]);
274
a87c263 @miyagawa mentions return value of psgi.input and psgi.errors methods
miyagawa authored
275 Returns the number of characters actually read, 0 at end of file, or
276 undef if there was an error.
277
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
278 =item seek
279
280 $input->seek($pos, $whence);
281
a87c263 @miyagawa mentions return value of psgi.input and psgi.errors methods
miyagawa authored
282 Returns 1 on success, 0 otherwise.
283
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
284 =back
285
286 =head3 The Error Stream
287
ff0e6de @miyagawa paragraphized
miyagawa authored
288 The error stream in C<psgi.errors> is an IO::Handle-like object to
289 print errors. The error stream must implement C<print>.
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
290
ff0e6de @miyagawa paragraphized
miyagawa authored
291 The built-in filehandle or IO::Handle based objects should work fine
292 everywhere. Application developers SHOULD NOT inspect the type or
293 class of the stream, but instead just call C<print> to duck type.
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
294
295 =over 4
296
297 =item print
298
299 $errors->print($error);
300
a87c263 @miyagawa mentions return value of psgi.input and psgi.errors methods
miyagawa authored
301 Returns true if successful.
302
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
303 =back
304
305 =head3 The Response
306
307 =head4 Status
308
309 HTTP status code, is an integer and MUST be greater than or equal to 100.
310
311 =head4 Headers
312
79b722f @miyagawa clarified it's not a hash ref
miyagawa authored
313 The headers must be an array reference (and NOT a hash reference!)
314 containing key and value pairs. Its number of elements MUST be
315 even. The header MUST NOT contain a C<Status> key, contain keys with
316 C<:> or newlines in their name, contain keys that end in C<-> or C<_>
317 but only contain keys that consist of letters, digits, C<_> or C<->
318 and start with a letter. The value of the header must be a scalar
319 value that contain a string. The value string MUST NOT contain
320 characters below chr(37).
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
321
ff0e6de @miyagawa paragraphized
miyagawa authored
322 If the same key name appears multiple times in an array ref, those
323 header lines MUST be sent to the client separately (e.g. multiple
324 C<Set-Cookie> lines).
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
325
326 =head4 Content-Type
327
ff0e6de @miyagawa paragraphized
miyagawa authored
328 There MUST be a C<Content-Type> except when the C<Status> is 1xx, 204
329 or 304, in which case there MUST be none given.
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
330
331 =head4 Content-Length
332
ff0e6de @miyagawa paragraphized
miyagawa authored
333 There MUST NOT be a C<Content-Length> header when the C<Status> is
334 1xx, 204 or 304.
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
335
1173dc0 @miyagawa New spec: feedbacks got merged.
miyagawa authored
336 If the Status is not 1xx, 204 or 304 and there is no C<Content-Length>
77b3dfe @miyagawa apps are not supposed to add Transfer-Encoding, remove it
miyagawa authored
337 header, servers MAY calculate the content length by looking at Body,
338 in case it can be calculated (i.e. if it's an array ref of body chunk
339 or a real file handle), and append to the outgoing headers.
1173dc0 @miyagawa New spec: feedbacks got merged.
miyagawa authored
340
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
341 =head4 Body
342
ff0e6de @miyagawa paragraphized
miyagawa authored
343 The response body is returned from the application in one of following
344 two types of scalar variable.
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
345
346 =over 4
347
348 =item *
349
350 An array reference containing body as lines.
351
352 my $body = [ "Hello\n", "World\n" ];
353
1173dc0 @miyagawa New spec: feedbacks got merged.
miyagawa authored
354 Note that the elements in an array reference are NOT REQUIRED to end
355 in a newline. The servers SHOULD just write each elements as is to the
356 client, and SHOULD NOT care if the line ends with newline or not.
357
358 So, when you have a big chunk of HTML in a single scalar C<$body>,
359
360 [ $body ]
361
362 is a valie response body.
363
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
364 =item *
365
366 An IO::Handle-like object or a built-in filehandle.
367
368 open my $body, "</path/to/file";
1173dc0 @miyagawa New spec: feedbacks got merged.
miyagawa authored
369 open my $body, "<:via(SomePerlIO)", ...;
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
370 my $body = IO::File->new("/path/to/file");
371
1173dc0 @miyagawa New spec: feedbacks got merged.
miyagawa authored
372 my $body = SomeClass->new(); # mock class that implements getline() and close()
373
0e5a284 @miyagawa more clarifications about what is Plack and what is Adapter. s/implem…
miyagawa authored
374 Servers SHOULD NOT check the type or class of the body but instead
0e5b33e @miyagawa Updated spec: body can respond ->path.
miyagawa authored
375 just call C<getline> (i.e. duck type) to iterate over the body and
376 call C<close> when done.
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
377
1173dc0 @miyagawa New spec: feedbacks got merged.
miyagawa authored
378 Servers MAY check if the body is a real filehandle using C<fileno> and
379 C<Scalar::Util::reftype> and if it's a real filehandle that has a file
380 descriptor, it MAY optimize the file serving using techniques like
381 I<sendfile(2)>.
382
0e5b33e @miyagawa Updated spec: body can respond ->path.
miyagawa authored
383 The body object MAY respond to C<path> method to return the local file
384 system path, which MAY be used by some servers to switch to more
385 efficient file serving method using the file path instead of a file
386 descriptor.
387
1173dc0 @miyagawa New spec: feedbacks got merged.
miyagawa authored
388 Servers are RECOMMENDED to set C<$/> special variable to the buffer
389 size when reading content from C<$body> using C<getline> method, in
390 case it's a binary filehandle. Applications, when it returns a mock
391 object that implements C<getline> are NOT REQUIRED to respect the
392 C<$/> value.
393
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
394 =back
395
1173dc0 @miyagawa New spec: feedbacks got merged.
miyagawa authored
396 =head2 Middleware
397
5d680fe @miyagawa s/existent/existing/
miyagawa authored
398 Middleware is itself a PSGI application but it takes an existing PSGI
a19c5ba @miyagawa minor grammer fixes
miyagawa authored
399 application and runs it like a server, mostly to do pre-processing on
1173dc0 @miyagawa New spec: feedbacks got merged.
miyagawa authored
400 C<$env> or post-processing on the response objects.
401
402 Here's a simple example that appends special HTTP header
403 I<X-PSGI-Used> to any PSGI application.
404
405 # $app is a simple PSGI application
406 my $app = sub {
407 my $env = shift;
408 return [ '200', [ 'Content-Type' => 'text/plain' ], [ "Hello World" ] ];
409 };
410
411 # $xheader is a middleware to wrap $app
412 my $xheader = sub {
413 my $env = shift;
414 my $res = $app->($env);
415 push @{$res->[1]}, 'X-PSGI-Used' => 1;
416 return $res;
417 };
418
419 Middleware itself MUST behave exactly like a PSGI application: take
420 C<$env> and return C<$res>.
421
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
422 =head1 ACKNOWLEDGEMENTS
423
424 Some parts of this specification are adopted from the following specifications.
425
426 =over 4
427
428 =item *
429
430 PEP333 Python Web Server Gateway Interface L<http://www.python.org/dev/peps/pep-0333>
431
432 =item *
433
434 Rack L<http://rack.rubyforge.org/doc/SPEC.html>
435
436 =item *
437
438 JSGI Specification L<http://jackjs.org/jsgi-spec.html>
439
440 =back
441
442 I'd like to thank authors of these great documents.
443
444 =head1 AUTHOR
445
446 Tatsuhiko Miyagawa E<lt>miyagawa@bulknews.netE<gt>
447
1173dc0 @miyagawa New spec: feedbacks got merged.
miyagawa authored
448 =head1 CONTRIBUTORS
449
450 The following people have contributed to the PSGI specification and
451 Plack implementation by commiting their code, sending patches,
452 reporting bugs, asking questions, suggesting useful advices,
453 nitpicking, chatting on IRC or commenting on my blog (in no particular
454 order):
455
456 Tokuhiro Matsuno
457 Kazuhiro Osawa
458 Yuval Kogman
459 Kazuho Oku
460 Alexis Sukrieh
048f9a3 @miyagawa update Dann's name. README links to the site
miyagawa authored
461 Takatoshi Kitano
1173dc0 @miyagawa New spec: feedbacks got merged.
miyagawa authored
462 Stevan Little
463 Daisuke Murase
464 mala
465 Pedro Melo
466 Jesse Luehrs
467 John Beppu
468 Shawn M Moore
469 Mark Stosberg
470 Matt S Trout
471 Jesse Vincent
472 Chia-liang Kao
473 Dave Rolsky
474 Hans Dieter Pearcey
475 Randy J Ray
476 Benjamin Trott
477 Max Maischein
478 Slaven Rezić
479 Marcel Grünauer
480 Masayoshi Sekimura
481 Brock Wilcox
482 Piers Cawley
ecdb6c0 @miyagawa added some HTTP::Engine contributors
miyagawa authored
483 Daisuke Maki
484 Kang-min Liu
485 Yukihiro Matsumoto
5623139 @miyagawa changed the Content-Length from SHOULD to MAY
miyagawa authored
486 Ash Berlin
31284b9 @miyagawa Added Artur for his advice around gearman/schwartz
miyagawa authored
487 Artur Bergman
ba2001a @miyagawa more questions around HTTP::Engine confusions
miyagawa authored
488 Simon Cozens
489 Scott McWhirter
a87c263 @miyagawa mentions return value of psgi.input and psgi.errors methods
miyagawa authored
490 Jiro Nishiguchi
01b3c47 @miyagawa Sorry!
miyagawa authored
491 Masahiro Chiba
1173dc0 @miyagawa New spec: feedbacks got merged.
miyagawa authored
492
e85dbb3 @miyagawa First draft of the PSGI spec and FAQ.
miyagawa authored
493 =head1 COPYRIGHT AND LICENSE
494
495 Copyright Tatsuhiko Miyagawa, 2009.
496
497 This document is licensed under the Creative Commons license by-sa.
498
499 =cut
Something went wrong with that request. Please try again.