You could then dispatch your request to each db and select on your socket connections, collecting replies as they come back.

Timeouts fall out of this fairly easily too, but you'll need to be careful if you subsequently re-use a socket and get a response to a timed-out query.

There are various wrappers around this. You can use IO::Socket and IO::Select as a starting point, but there are probably higher-level modules. Anyone else got any ideas?

So something like this:

sub metasearch {
  my $self = shift;
  # Note: could make dbs return array in array context
  # with 'wantarray'
  my @dbs = @{$self->dbs};

  my @db_socks;
  foreach my $db (@dbs) {
    my $sock = $db->connect;
    send_nonblocking_query($sock);
    push @db_socks, $sock;
  }
  my $timeout_at = time() + $timeout_secs;
  while (@db_socks && time() < $timeout_at) {
    ..select on @db_socks, timing out at timeout_at
    ..handle a wakeup on a socket by reading the response
  }

  # error handling of remaining @db_socks
}
[download]

Your separate daemon could very well be just another mod_perl process.

⠤⠤ ⠙⠊⠕⠞⠁⠇⠑⠧⠊

Thanks for all the suggestions but does anyone have any pointers either to docs or better yet sample code?

Search for "mod_perl" and "fork" or "threads" tend to give lots of hits about apache MPMs but very little about fork/threads within mod_perl

POE looks very interesting but also very much like a whole new framework to learn. It is on my todo list but I had hoped for something I could use after reading a man page or two but not hundreds of them ;-)

http://modperlbook.org/html/10-2-Forking-and-Executing-Subprocessesfrom-mod_perl.html

Thanks for the pointer, I tried to follow the example as close as possible and came up with this (not proberly working) code:

sub metasearch {
    my $self = shift;
    my $db_ref = $self->db_defs;
    my @dbs = @{$self->dbs};
    my $logger = $self->logger;

    $SIG{CHLD} = 'IGNORE';
    my @result;
    foreach my $db (@dbs) {
        defined (my $kid = fork) or die "Cannot fork: $!\n";
        $logger->debug("Processing $db in process $kid");
        if ($kid) {
            $logger->debug("Parent $$ has finished, kid's PID: $kid");
        }
        else {
            # $r->cleanup_for_exec(); # untie the socket
            open STDIN, '/dev/null' or die "Can't read /dev/null: $!";
            open STDOUT, '>/dev/null' or die "Can't write to /dev/null
+: $!";
            open STDERR, '>/tmp/log' or die  "Can't write to /tmp/log:
+ $!";
            # setsid or die "Can't start a new session: $!";
            my $oldfh = select STDERR; local $| = 1; select $oldfh;
            warn "started\n";
            sleep 1, warn "$_\n" for 1..20;
            warn "completed\n";
            push @result, "simulate result for $db in $kid";
            CORE::exit(0); # terminate the process
        }
        $logger->debug("End of $db");
    }
    $logger->debug(join(', ', @result));
}
[download]

The difference is a foreach around the forks and the attempt to collect some result from the forked processes in @result but @result is empty.

What am I doing wrong?

As a side-note since I am not really interested in the warn-output: /tmp/log is empty after the run. Does this indicate that the child(s) didn't run?

I left out the cleanup_for_exec and the setsid lines because from the explanation I gathered they are not necessary in my situation and I didn't know if cleanup_for_exec call is still the same in mod_perl2 (the example is for mod_perl1)