in reply to A suicidal parent OR death of a forking server

You don't have any synchronicity problem if you don't fork. So don't fork. use IO::Select instead. 
#!/usr/bin/perl

use strict;
use warnings;

use IO::Socket::INET qw( );
use IO::Select       qw( );


sub process_msg {
    my ($client, $msg) = @_;
    chomp $msg;
    my $host = $client->peerhost;
    print "$host said '$msg'\n";
    return lc($msg) ne 'quit';
}


my $server = IO::Socket::INET->new(
    ...
) or die("Couldn't create server socket: $!\n");

my $select = IO::Select->new($server);

my %bufs;

while (my @ready = $select->can_read) {
    for my $fh (@ready) {
        if ($fh == $server) {
            my $client = $server->accept;
            $select->add($client);
            $bufs{fileno($client)} = '';

            my $host = $client->peerhost;
            print "[Accepted connection from $host]\n";
        }
        else {
            our $buf; local *buf = \$bufs{fileno($fh)};
            my $rv = sysread($fh, $buf, 64*1024, length($buf));
            if (!$rv) {
                my $host = $fh->peerhost;
                if (defined($rv)) {
                    print "[Error reading from host $host]\n";
                } else {
                    print "[Connection from $host terminated]\n";
                }
                process_msg($fh, $buf) if length($buf);
                delete $bufs{fileno($fh)};
                $sel->remove($fh);
                next;
            }

            while ($buf =~ s/\G(.*\n)//) {
                if (!process_msg($fh, "$1")) {
                    my $host = $fh->peerhost;
                    print "[Connection from $host terminated]\n";
                    delete $bufs{fileno($fh)};
                    $sel->remove($fh);
                    last;
                }
            }
        }
    }
}

[download]

Replies are listed 'Best First'.
Re^2: A suicidal parent OR death of a forking server
by ikegami (Patriarch) on Jun 09, 2010 at 18:57 UTC

    Instead of implementing a limited cooperative multitasking system using select, it's simpler to use threads or Coro.

    The following is the Coro equivalent of the code in the parent post. 

    #!/usr/bin/perl

use strict;
use warnings;

use Coro             qw( async );
use IO::Socket::INET qw( );

sub client {
    my ($sock) = @_;

    my $host = $client->peerhost;
    print "[Accepted connection from $host]\n";

    while (!eof($sock)) {
        my $msg = <$sock>;
        if (!defined($msg)) {
            print "[Error reading from host $host]\n";
            return;
        }

        print "$host said '$msg'\n";
        last if $msg eq 'quit';
    }

    print "[Connection from $host terminated]\n";
}

my $server = IO::Socket::INET->new(
    ...
) or die("Couldn't create server socket: $!\n");

async(\&client, $server->accept) while 1;

    [download]
[reply]
[d/l]
[select]
      Instead of implementing a limited cooperative multitasking system using select, it's simpler to use ... Coro.

      But what you've posted here is just as limited as the select version (that you also posted). It's not multi-tasking, Just cooperative time-sharing.

      It suffers from all the same limitations and caveats as the select implementation, except that they are stuffed under the cover of a "pretty interface".

      Limitations that include:

      • The inability to scale across multiple cores.
      • The need to break up cpu-intensive processing into "bite-sized chunks".

      Yesterdays years decades solution masquerading as something new, that headlines with what is both a factual and technical lie.

      Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.
      "Science is about questioning the status quo. Questioning authority".
      In the absence of evidence, opinion is indistinguishable from prejudice.
[reply]
        Simply put, you don't need to save your entire state manually between blocking calls. That's a huge difference if you ask me. If one hits the limits of Coro or needs multiple cores, one can easily switch to thread, forks or fork.
[reply]
[d/l]

        I have been advertising the fact that Coro only provides cooperative multitasking, so no news.

        What's wrong with using the appropriate tool for the job? I could easily have used threads, forks or fork — two of those would simply require the addition of ->detach — but since there was no requirement for that overhead, I used the lightweight solution.

[reply]
[d/l]
[select]

In Section Seekers of Perl Wisdom