Am I doing things correctly?

Not entirely, I suspect. You have 2 different CGI objects: 1 in test.cgi and 1 in Myapp. That seems inherently incorrect. Take the object you already have in test.cgi and pass it to the Myapp subs if that's what you want. Alternatively you could have Myapp subclass CGI::Fast and then just use that in test.cgi and call methods on that object from there. Or if you don't want to subclass CGI::Fast you could have a separate object of Myapp on which to call methods. TIMTOWTDI.

Here's a simplified example using that last of these approaches:

#!/usr/bin/perl -T

package Myapp;

use strict;
use warnings;

use Try::Tiny;

sub new {
    my ($class, $q) = @_;
    return bless {q => $q}, $class;
}

sub appy {
    my $self = shift;
    my $action = $self->{q}->param('action') || 'bailout';

    try { $self->$action; }
    catch { print "Unrecognized action : $action\n"; }
}

sub do_something {
    print "do something called\n";
}

package main;

use strict;
use warnings;

use CGI::Fast;
use Try::Tiny;

my $n = 0;

while (my $q = CGI::Fast->new) {
    my $query = $q->param('node');
    print "Content-type: text/plain\n\n";
    ++$n;
    print "You are request number $n. Have a good day!\n";
    print "query: $query\n";
    my $app = Myapp->new ($q);
    try { $app->$query }
    catch { error() };
    print "done!\n";
}

sub error {
    print "An error occurred.\n";
}
[download]

Note that I've combined the module and script into one file for ease of this illustration (it's an SSCCE, albeit you need an FCGI-capable webserver to test it). If you want to split them out again, just add use Myapp; back into the script. I've added Try::Tiny to catch the missing methods rather than bother with dispatch tables just to show another way of doing this but there's nothing wrong with dispatch tables if you prefer them. Equally you could just use UNIVERSAL::can to test the method's existence - so many options! I've used strict and warnings everywhere and so should you.

To answer the other avenue of discussion, the while loop is absolutely necessary otherwise you will not have the persistence (ie. $n will never increase). Have a think for yourself about why this is.

Thank you so much for your explanation on the "while" vs "if" condition and for your beautiful code - as someone who writes procedural code, I never quite get round to switching to object-oriented. Will try to learn (and adapt) from yours.

I have a question about persistence. Suppose the module Myapp uses other modules, are these other modules also stored in memory so they are not loaded for every request?

Suppose the module Myapp uses other modules, are these other modules also stored in memory so they are not loaded for every request?

Short answer: yes.

Any module which a script uses is loaded into memory at compile time, including all the modules used by those modules and so on. This memory stays used until the script exits. For long-running scripts such as those under FCGI this means that all those modules remain in memory for a long time. Each web request to your FCGI script will either encounter an existing FCGI process where all those modules are ready and therefore have no startup penalty or occasionally will have to spin up a fresh FCGI process which will take longer because it loads all the modules.

You can manage this somewhat by loading modules on demand at run-time instead of at compile time. Suppose there's a task your script will need to perform only once in every 10,000 runs and which needs a heavy module. You would not necessarily want that module taking up lots of RAM unnecessarily for 9,999 runs when it isn't needed. This sort of memory and process management is something you will probably want to consider if you are going to use FCGI (or any other persistent back-end) for serious purposes.

---

🦛

use strict;
use warnings;
[download]

while ( my $q = new CGI::Fast ) {
    my $query = $q->param('node');
    print "Content-type: text/plain\n\n";
    ++$n;
    print "You are request number $n. Have a good day!\n";
    print "query: $query\n";
    $nodes{ exists $nodes{$query} ? $query : '_err' }();
    print "done!\n";
}
[download]

You're not actually calling do_something in any execution path. And you don't need to use CGI in your package just to get the query option. You should be able to get it in the call to CGI::Fast and pass it to a method in your package, assuming you actually call it.

Maybe nodes{ exists $nodes{$query} ? $query : '_err' }(); needs to be nodes{ exists $nodes{$query} ? $query : '_err' }->(); ... sorry missed that it was a real hash.

Yeah you got a lot going on. Simplify it. Get rid of the package stuff, make sure your dispatching is clear, and make sure one of your terminal methods actually terminates. Hard to tell at first glance, but I still think your while is causing you some grief.

Also, I think you want an if, not a while

No, that's how you're supposed to use CGI::Fast, as a glance into the documentation would have told you. The whole point of FCGI is a persistent process.

strict/warnings would not have caught the infinite loop tho

It would?

(Somehow I missed the "not" in that sentence, my apologies.)

Maybe nodes{ exists $nodes{$query} ? $query : '_err' }(); needs to be nodes{ exists $nodes{$query} ? $query : '_err' }->();

No.

hippo's answer is correct: The problem is there are two CGI objects in the program.

Thanks for pointers. I see most examples on the Internet use "while", and I'm not really sure why. Would "if" work too?

Try it without the while loop and see what happens