PSGI and Plack provide a common interface (PSGI) and shared infrastructure (Plack) for building web applications and frameworks in Perl. PSGI defines a standard way for applications to communicate with web servers through a request/response interface. Plack provides many server implementations like FastCGI and standalone that can run PSGI applications. It also includes middleware, testing tools, and utilities to help developers. This new approach allows frameworks and applications to focus on their logic while reusing common plumbing through PSGI and Plack.

1. PSGI and Plack
Tatsuhiko Miyagawa
San Francsico.pm Nov. 24, 2009

2. Background

3. Web Frameworks

4. Maypole Mason Mojo Sledge Catalyst Spoon PageKit
AxKit Egg Gantry Continuity Solstice Mojolicious
Tripletail Konstrukt Reaction Jifty Cyclone3 WebGUI
OpenInteract Squatting Dancer CGI::Application
Nanoa Ark Angelos Noe Schenker Tatsumaki
Web::Simple Apache2::REST SweetPea Hydrant

5. Most of them run on
mod_perl and CGI

6. Some run on FastCGI

7. Some run standalone

8. Very few supports
non-blocking

9. Because:

10. No common server
environment layers

11. CGI.pm

12. Runs “fine” on:
CGI, FastCGI, mod_perl (1 & 2)
Standalone (with HTTP::Server::Simple)

13. CGI.pm = LCD
It’s also Perl core

14. Catalyst
The most popular framework as of today

15. Catalyst::Engine::*
Server abstractions.
Well supported Apache, FCGI and Standalone
No CGI.pm

16. CGI.pm
Jifty, CGI::Application, Spoon
mod_perl centric
Mason, Sledge, PageKit, WebGUI
Adapters
Catalyst, Maypole, Squatting

17. Problems:
Duplicated efforts
No fair performance evaluations

18. Question:
Can we share
those adapters?

19. Answer:
HTTP::Engine

20. HTTP::Engine
Lots of adapters (FCGI, Apache2, POE)
Clean Request/Response API
Written by Yappo, tokuhirom and others

21. Problems

22. Mo[ou]se everywhere
Mouse is light but still overspec for some env.

23. Monolithic
All implementations share HTTP::Engine roles
and builders, which is sometimes hard to adapt
and has less place for optimizations.

24. APIs everywhere
Most frameworks have their request/response API
Sometimes there are gaps.
Annoying to write bridges and wrappers

25. Solution

26. Steal good stuff
from Python/Ruby

27. WSGI (Python)
Rack

28. WSGI (PEP-333)
mod_wsgi, Tornado, Paste, GAE
Django, CherryPy, Pylons

30. Rack
Passenger, Thin, rack, Heroku
Rails, Merb, Sinatra

32. WSGI/Rack
Completely separate interface
from the actual implementation

33. Approach
Split HTTP::Engine
into three parts

34. Interface
Implementations
Utilities

35. PSGI (interface)
Plack::Server (implementations)
Plack::* (utilities)

36. Who’s on board
Benjamin Trott, Yuval Kogman, Stevan Little, Shawn M
Moore, Mark Stosberg, Matt S Trout, Jesse Vincent,
Chia-liang Kao, Dave Rolsky, John Beppu ...

37. Who’s on board
Authors of: Movable Type, WebGUI, Catalyst, Jifty,
Moose, DateTime, DBIx::Class, CGI::Application,
Squatting, SVK, Dancer

38. PSGI
Perl Web Server Gateway Interface

39. Interface

40. WARNING
You DON’T need to care about these
interface details as an app developer.

41. my $app = sub {
my $env = shift;
# ...
return [ $status, $header, $body ];
};

42. PSGI application
code reference
$app = sub {...};

43. my $app = sub {
my $env = shift;
# ...
return [ $status, $header, $body ];
};

44. environment hash
$env: CGI-like env variables
+ psgi.input, psgi.errors etc.

45. my $app = sub {
my $env = shift;
# ...
return [ $status, $header, $body ];
};

46. Response
array ref with three elements
status code, headers (array ref)
and body (IO-like or array ref)

47. my $app = sub {
my $env = shift;
# ...
return [ $status, $header, $body ];
};

48. $body
IO::Handle-like
getline() and close()

49. IO::Handle-like
We really envy Python/Ruby
for built-in iterators
(Perl’s filehandle is also an object, but it really sucks)

50. WARNING
You DON’T need to care about these
interface details as an app developer.
Becuase ...

51. Frameworks
Write an adapter to return
PSGI application code ref.
(and forget about servers!)

52. Framework Adapters
CGI::Application, Catalyst, Maypole
Mason, Squatting, Mojo, HTTP::Engine etc.

53. Applications
MT::App, WebGUI

54. use Foo; # is a Catalyst application
Foo->setup_engine(‘PSGI’);
my $app = sub { Foo->run };

55. Servers
Set up $env, run the app
and emits response out of $res

56. Plack
namespace for servers and utilities

57. Plack::Server
reference server implementations
Standalone, FCGI, Apache2, CGI
Standalone, Prefork, AnyEvent, Coro

58. Very fast
5000 QPS on standalone
15000 QPS with prefork :)

59. Utilities

60. Plackup
Run PSGI app instantly from CLI
(inspired by rackup)

61. DEMO

62. Middlewares

63. my $app = sub {
my $env = shift;
return [ $status, $header, $body ];
};
my $mw = sub {
my $env = shift;
# do something with $env
my $res = $app->($env);
# do something with $res;
return $res;
};

64. Middlewares
Static, AccessLog, ConditionalGET
ErrorDocument, StackTrace etc.

66. Plack::Middleware
reusable and extensible
Middleware framework
Plack::Builder DSL in .psgi

67. my $app = sub {
return [ $status, $header, $body ];
};
use Plack::Builder;
builder {
enable “Static”, root => “/htdocs”,
path => qr!^/static/!;
enable “Deflater”; # gzip/deflate
$app;
}

68. Plack::App::URLMap
Multiplex multiple apps
Integrated with Builder DSL

69. use CatApp;
use CGIApp;
my $c1 = sub { CatApp->run };
my $c2 = sub { CGIApp->run_psgi };
use Plack::Builder;
builder {
mount “/cat” => $c1;
mount “/cgi-app” => builder {
enable “StackTrace”;
$c2;
};
}

70. CGI::PSGI
Easy migration from CGI.pm

71. Plack::Request
like libapreq (Apache::Request)
wrapper APIs for framework developers

72. use Plack::Request;
my $app = sub {
my $req = Plack::Request->new(shift);
my $body = “Hello “ . $req->param(‘n’);
my $res = $req->new_response(200);
$res->content_type(‘text/plain’);
$res->body($body);
return $res->finalize;
};

73. Plack::Test
Unified interface to write tests
with Mock HTTP and Live HTTP

74. use Plack::Test;
use HTTP::Request::Common;
my $app = sub {
my $env = shift;
return [ $status, $header, $body ];
};
test_psgi app => $app, client => sub {
my $cb = shift;
my $req = GET “http://localhost/foo”;
my $res = $cb->($req);
# test $res;
};

75. use Plack::Test;
use HTTP::Request::Common;
$Plack::Test::Impl = “Server”;
my $app = sub {
my $env = shift;
return [ $status, $header, $body ];
};
test_psgi app => $app, client => sub {
my $cb = shift;
my $req = GET “http://localhost/foo”;
my $res = $cb->($req);
# test $res;
};

76. Streaming
event loop / long-poll

77. # Pull streaming for blocking server
use IO::Handle::Util qw(io_from_getline);
my $app = sub {
my $env = shift;
my $io = io_from_getline sub {
return $chunk; # undef when done
};
return [ $status, $header, $io ];
};

78. # Push streaming for non-blocking server
use AnyEvent;
use JSON;
my $app = sub {
my $env = shift;
return sub {
my $respond = shift;
my $w = $respond->([ 200, $headers ]);
AnyEvent::Example->fetch(sub {
$w->write(JSON::encode_json($_[0]));
$w->close;
});
};
};

79. Non-blocking servers
AnyEvent, Coro, POE, Danga::Socket

80. Non-blocking framework
Tatsumaki
(Demo later)

81. Other Servers

82. nginx embedded perl
http://github.com/yappo/nginx-psgi-patchs

83. mod_psgi
http://github.com/spiritloose/mod_psgi

84. evpsgi
http://github.com/sekimura/evpsgi

85. Perlbal plugin
http://github.com/miyagawa/Perlbal-Plugin-PSGI

86. Cloud

87. WSGI (PEP-333)
mod_wsgi, Tornado, Paste, GAE
Django, CherryPy, Pylons

88. Rack
Passenger, Thin, rack, Heroku
Rails, Merb, Sinatra

89. What if GAE Perl
comes with PSGI ...

90. Summary
• PSGI is an interface, Plack is the code.
• We have many (pretty fast) servers.
• We have adapters and tools for most web
frameworks.
• Use it!

91. http://github.com/miyagawa/Plack
http://plackperl.org/

92. Questions?