How do you implement non-blocking responses in a perl plack app?

Question

I'm trying to write a a perl-based webserver using Twiggy::Server (which means a plack app). I want to respond to a request (coming from an ajax call on a webpage) for some data by running some possibly time-consuming subroutine which generates the data and then turns it into a JSON string for returning to the client webpage.

You can see a cut-down test version of my server here: http://pastebin.com/iNaDTVwL That example shows the problem I'm facing with my current implementation; using AnyEvent::ForkManager to do the non-blocking part of things results in truncation of the 'big' json response.

This document would answer my questions perfectly (and better explains what I'm trying to do): https://github.com/jjn1056/Example-PlackStreamingAndNonblocking ... if it was finished. I'm just missing the 'proper' way of doing non-blocking, instead of using AnyEvent::ForkManager which seems like a bit of a hack.

I'm a little unclear on what you're trying to make nonblocking. I can't easily give specifics on Plack etc., but if it's file or socket IO... there's plenty of standard solutions. — Sobrique, Jul 09 '14 at 14:52
Ideally I was looking for something generic that could take any black-box subroutine and run it non-blocking. But if that wouldn't be possible, then an example of the time-consuming bit of one of the subroutines is querying another server via its REST interface. — sbs, Jul 09 '14 at 17:55
Ah, process wise? OK. You may wish to look at threads and threading, or alternatively using `fork()` Which to use depends on how tightly coupled your data is - threading is good for sharing memory with e.g. semaphores and queues - passing data back and forth between threads is relatively easier. Forking is probably more performance, but only if you don't need to synchronise later. Feeding data back and forth between forked processes is a pain. Just be warned - parallel processing is a whole world of pain if you're not careful - you can create some really fascinating bugs. — Sobrique, Jul 09 '14 at 18:50
Yes, my current implementation does it with an async fork (AnyEvent::ForkManager), but I was hoping this was a standard thing to do and people would have specific code examples of how something like this is normally done. — sbs, Jul 09 '14 at 19:05
I quite like rolling my own, before potentially throwing it away and using a module. So with that in mind - I can offer a sample of how to thread in perl using queues. — Sobrique, Jul 09 '14 at 19:08

score 1 · Answer 1 · answered Jul 10 '14 at 16:10

Personally I'd use Net::Async::HTTP::Server::PSGI. From its SYNOPSIS:

use Net::Async::HTTP::Server::PSGI;
use IO::Async::Loop;

my $loop = IO::Async::Loop->new;

my $httpserver = Net::Async::HTTP::Server::PSGI->new(
   app => sub {
      my $env = shift;

      return [
         200,
         [ "Content-Type" => "text/plain" ],
         [ "Hello, world!" ],
      ];
   },
);

$loop->add( $httpserver );

$httpserver->listen(
   addr => { family => "inet6", socktype => "stream", port => 8080 },
   on_listen_error => sub { die "Cannot listen - $_[-1]\n" },
);

$loop->run;

Obviously this particularly tiny example doesn't demonstrate anything asynchronous, but you have full access to all of the IO::Async system in order to defer and respond later.

score 0 · Answer 2 · answered Jul 10 '14 at 10:25

So following on from the comments - I don't know enough about the things you're using to give you a specific response, but can offer up something generic.

Using threads to 'async' part of your Perl script:

#!/usr/bin/perl

use strict;
use warnings;

use threads;
use Thread::Queue; 

my $input_q = Thread::Queue -> new();
my $success_q = Thread::Queue -> new(); 
my $failure_q = Thread::Queue -> new();

my $thread_count = 4; 

sub spinoff_thread {
    while ( my $target = $input_q -> dequeue() )
    {
       #do something to $target
       my @results = `ping -c 10 -i 1 $target`;
       if ( $? ) { 
           $failure_q -> enqueue ( $target );
       }
       else {
           $success_q -> enqueue ( $target );
       }
    } 
}

#main bit

for ( 1..$thread_count ) {
    my $thr = threads -> create ( \&spinoff_thread );
}

foreach my $server ( "server1", "server2", "server3", "server4", "server5" ) {
  $input_q -> enqueue ( $server );
}

$input_q -> end(); #will cause threads to 'bail out' because that while loop will go 'undef'); 

 #wait for threads to complete. 
foreach my $thr ( threads -> list() ) {
   $thr -> join();
}


print "Fail:\n", join ("\n", $failure_q -> dequeue() ), "\n";
print "Success:\n"; join ( "\n", $success_q -> dequeue() ), "\n";

The key points being that your threads - are basically subroutines - and can pass things back and forth using the Queues. end the queue is a good way to handle telling a thread to terminate - there are other ways of course.

How do you implement non-blocking responses in a perl plack app?

2 Answers2