head

Image

code

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

FastCGI::NativeCall::Async - An asynchronous wrapper for FastCGI::NativeCall


=begin code

use FastCGI::NativeCall::Async;

my $fna = FastCGI::NativeCall::Async.new(path => "/tmp/fastcgi.sock", backlog => 32 );

my $count = 0;

react {
    whenever $fna -> $fcgi {
        say $fcgi.env;
        $fcgi.Print("Content-Type: text/html\r\n\r\n{++$count}");
    }

}

=end code


The rationale behind this module is to help
L<FastCGI::NativeCall|https://github.com/jonathanstowe/raku-fcgi-nativecall>
play nicely in a larger program by managing the blocking accept loop as
a Supply that can for instance be used in a C<react> block as above.
It doesn't actually allow more than one FastCGI request to be processed at
once for the same URI as the protocol itself precludes that.  However it
does allow more than one FastCGI handler to be present in the same
 program, potentially sharing data and other resources.


The interface is very simple and much of the functionality is delegated
to L<FastCGI::NativeCall|https://github.com/jonathanstowe/raku-fcgi-nativecall>.


method new(FastCGI::NativeCall::Async:U:  Str :$path, Int :$backlog = 16)


The constructor must be supplied with the path where the listening Unix domain
socket will be created, the location must be accessible to both your program
and the host HTTP server which will be delivering the requests.


The C<backlog> option, which defaults to 16, is the number of yet to be
accepted requests that can be queued before subsequent requests receive
an error, you may want to adjust this (in concert with the configuration
of your host HTTP server,) to achieve an acceptable level of throughput
for your application.


method Supply(FastCGI::NativeCall::Async:D: --> Supply)


This returns a L<Supply> on to which the L<FastCGI::NativeCall> object
is emitted for each incoming request. This acts as a coercion on the
FastCGI::NativeCall::Async object so may not need to be typed explicitly
in some places (such as in a C<whenever> of a C<react> block as in the
Synopsis.)


This method, when first called, creates a thread that runs the normal
C<Accept> loop of FastCGI::NativeCall in the background, any subsequent
calls will return the same supply fed with the same data.  To end the
loop use C<done> described below.


method promise(FastCGI::NativeCall::Async:D: --> Promise)


This is the promise that is provided by starting the underlying thread,
it will not be defined until C<Supply> has been called.  It will be
kept when the thread completes after C<done> is called.


method done(FastCGI::NativeCall::Async:D:)


This terminates the loop started when C<Supply> is first called,
afterward the Supply will no longer be fed with new requests.
When the thread has completely finished the Promise returned
by C<promise> will be kept.


After this has been called you will need to create a new object
to commence responding to requests as the FastCGI object will
have been closed.



class FastCGI::NativeCall::Async {
    use FastCGI::NativeCall;

    has Str  $.path;
    has UInt $.socket is default(0);
    has Int  $.backlog is default(16);

    has FastCGI::NativeCall $!fcgi;

    method fcgi(--> FastCGI::NativeCall) {
        $!fcgi //= do {
            if $!path {
                FastCGI::NativeCall.new(:$!path, :$!backlog);
            }
            else {
                FastCGI::NativeCall.new(:$!socket);
            }
        };
    }

    has Supplier $!supplier;

    method supplier(--> Supplier) {
        $!supplier //= Supplier.new;
    }

    has Supply $!supply;

    has Promise $.promise;

    has Promise $!continue-promise;

    method Supply(--> Supply) {
        if !$!supply.defined {
            $!supply = self.supplier.Supply;
            $!promise = start {
                $!continue-promise = Promise.new;
                while await Promise.anyof($!continue-promise, self!accept) {
                    last if $!continue-promise;
                    self.supplier.emit(self.fcgi);
                }
            }
        }
        $!supply;
    }

    method !accept(--> Promise) {
        start {
            self.fcgi.accept;
        }
    }

    method done() {
        if $!continue-promise.defined {
            $!continue-promise.keep: True;
            self.fcgi.close;
            $!supplier.done;
        }
    }
}
# vim: expandtab shiftwidth=4 ft=raku


Async

The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

FastCGI::NativeCall::Async

image i_github_com_jonathanstowe_fastcgi_nativecall_async_workflows_ci_badge_svg not found

Synopsis

Description

Installation

Support

Licence & Copyright

FastCGI::NativeCall::Async v0.0.6

Authors

License

Dependencies

Test Dependencies

Provides

Documentation