At work, we have apps that make money and perform as they need to, but don't have enough changes that it makes sense to spend the time to rewrite them in Modern Perl.

Where are we starting?

• The apps have been in maintenence mode for several years

• Started as CGI scripts in the '90s
  • Some code is old enough to drink
• Minor modifications to make them run under mod_perl
• There are tickets to rewrite with Modern::Perl
  • but the business case is not there

Why change what works?

• Most infrastructure is moving from Red Hat + Apache to CentOS + Nginx
  • Driven by the Ops team
• Newer apps also aren't stuck using the system perl
• Internal shared modules can then stop having perl 5.8 compatability

Decided to turn it into a Plack app

• Plack can easily talk to Nginx over FCGI
  • But has other options to interface with things other than FCGI
• On the other end, I had seen several useful looking modules to help me.
  • At least promises of help
• And of course Middleware support

Lets do this

• Tried Plack::App::FakeApache1
  • It may work great
  • I couldn't figure out how
  • Asked the author for help
  • he said sure, but didn't
  • Whew!
• Looked harder

Challenges

• CGIs, FCGI, and mod_perl communicate via STDIN and STDOUT
  • and environment variables

• PSGI doesn't work that way
  • It arguments and returns a hashref
• Sounding like a LOT of work
  • Slighty worried
  • Old code prints to STDOUT in terribly creative ways
  • It uses the Apache module for several things

What am I going to do?

• Not Apache2 + mod_perl
  • The rest of the infrastructure is going to Nginx + FCGI
• Not Plack::App::WrapCGI
  • The compilation and loading was already working for mod_perl

Ended up with CGI::Emulate::PSGI

• It turned out really easy to get started
• We were already precompiling our app for Apache
• We had a function to handle the request already

my $psgi_app = CGI::Emulate::PSGI->handler( sub { $app->handle_legacy_request() } );

• Hurray!
• And added features from there

app.psgi

 use CGI::Emulate::PSGI;
 ...;

 my $psgi_app = CGI::Emulate::PSGI->handler( sub {
    ...;
    $app->use($site); # changes $app->site

    # Nginx would normally do this.
    # If we're running under a different server, we may not get that.
    (my $path_info = $ENV{PATH_INFO} || '') =~ s{^/}{};
    if ( $path_info and my $file = $app->find_htdoc($path_info) ) {
        return serve_static($file);
    }

    return $app->handle_legacy_request;
 } );

 # From Plack::App::File which doesn't work with an ever changing $app->site.
 sub serve_static { ...; }

Removed the Apache module

• Mostly things like switching from Apache::Cookie to CGI::cookie()

 -    Apache::Cookie->new($r, -name  => $name, -value => $value)->bake;
 +    http_header( 'cookie' => CGI::cookie( -name  => $name, -value => $value ) );

• Lack of Apache::Request meant we had to get that info elsewhere.
  • Mostly from the %ENVironment

 -    Apache->request->status(301);
 -    http_header( Location => $location );
 -    send_http_header();
 +    print CGI::redirect( -uri => $location, -status => '301 Moved Permanently' );

 # After sending the headers:
 +    $GLOBAL{HEADER_SIZE} = tell STDOUT;
 # Then at the end of the request
 -    my $bytes_sent = Apache->request->bytes_sent;
 +    my $bytes_sent = tell(STDOUT) - ($GLOBAL{HEADER_SIZE} || 0);

Changes from perl/system replacement

• We're switching to plenv + carton. Not quite to deploying yet. Soon.
• Been testing on 5.20.0 and surprisingly few changes needed so far
  • Due to lack of testing of our shared modules, sticking with 5.16
• The OS is now relatively unimportant
  • Should be able to change it easily in the future

Annoyance that still needs work

• Forking a background process
  • FCGI::Request ->Detach and ->Attach
  • Haven't found a good way to get the Request to where I background
• Deployment
  • unrelated to this, it's plenv + Carton
  • may be solved by CoreOS and Docker
• Workarounds on Plack to get logging back what we expect

Interesting Tidbits

• Used tell(STDOUT) after sending headers and body to calculate size for logging
• Used `local *STDERR` to avoid log messages from ill-behaving modules
• plackup Just Works
  • it's like a real CGI server in perl
• A bug in CGI::Emulate::PSGI was commited and fixed while I was testing

Questions?

Questions?

Questions?

use strict;
our %GLOBAL;

my %key_map = (
    #'status', #'-expires',
    '-content_type' => '-type',
    '-set_cookie'   => '-cookie',
    '-cookies'      => '-cookie',
);

my %allowed_multiple_values = map { $_ => 1 } (
    '-cookie',
    '-p3p',
);

my @HTTP_HEADERS;    # file local variable

sub http_header { push @HTTP_HEADERS, [@_] if @_ }

sub send_http_header {
    my $content_type = shift;

    push @HTTP_HEADERS, [ type => $content_type ] if $content_type;

    if ( $GLOBAL{id} ) {
        push @HTTP_HEADERS, (
            [ 'cache-control' => 'no-cache,no-store,must-revalidate' ],
            [ 'expires'       => '-1' ],
        );
    }

    my %headers;
    foreach (@HTTP_HEADERS) {
        my ( $key, $value ) = @{ $_ };

        # make the keys uniform so we throw away any duplicates
        $key = lc $key;     # lowercase
        $key =~ s/^-//;     # remove an optional leading daesh
        $key =~ s/-/_/g;    # change dashes to underscores
        $key = "-$key";     # and put back the required leading dash
        $key = $key_map{$key} || $key;    # see if we have a custom map

        next if $key eq '-';    # no empty headers

        if ($allowed_multiple_values{$key}) {
            push @{ $headers{$key} }, $value;
        }
        else {
            $headers{$key} = $value;
        }
    }

    @HTTP_HEADERS = ();                      # Reset

    print CGI::header(%headers);

    $GLOBAL{HEADER_SIZE} = tell STDOUT;
}