NAME

head

my $service = Cro::FCGI::Server.new(
    host => '127.0.0.1',
    port => 43210,
    application => MyCroApp
);
$service.start;


Listen 43210
<VirtualHost 127.0.0.1:43210>
    ProxyFCGIBackendType GENERIC
    ProxyPass "/" "fcgi://127.0.0.1:43211/" enablereuse=on
</VirtualHost>


my $service = Cro::FCGI::Server.new(
    socket-path => '/run/cro-fcgi/my-cro-app.sock',
    application => MyCroApp
);
$service.start;


Listen 43210
<VirtualHost 127.0.0.1:43210>
    ProxyFCGIBackendType GENERIC
    ProxyPass "/" "unix:/run/cro-fcgi/my-cro-app.sock|fcgi://127.0.0.1/" enablereuse=on
</VirtualHost>


This module provides a FastCGI frontend for Cro. It allows a simple coupling of
a webserver and Cro application.


The module provides a drop-in replacement for C<Cro::HTTP::Server> named
C<Cro::FCGI::Server>. It can be instantiated for either a network connetion or a
Unix socket connection.


To start listening on a network port pass the C<host> and C<port> arguments.


To start listening on a Unix socket, pass the C<socket-path> argument. Make
sure the socket is readable and writable by the webserver process. Note that
SELinux can possibly block access to the socket file for the webserver.


To access the remote and local host and port of the connection of a given
request, use the C<.socket-host>, C<.socket-port>, C<.peer-host>
and C<.peer-port> methods of the request object, I<not> the
equally named methods of the C<Cro::Connection> object
(C<$request.connection.*>). With FCGI, the connection represents the connection
to the webserver, not the client!


Currently starting the application process automatically is not supported. You
have to start the Cro application separately. For Apache this means you should
use C<mod_proxy_fcgi> instead of C<mod_fcgid>.


Patrick Böker <patrick.boeker@posteo.de>


AUTHOR

This module is distributed under the terms of the Artistic License 2.0.


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

Cro::FCGI


use Cro::BodyParser;
use Cro::HTTP::Message;
use JSON::Class;



Cro::HTTP::BodyParser::JSONClass - Parse and deserialise application/json HTTP body to a specified JSON::Class


code

=begin code :lang<raku>

use Cro::HTTP::Router;
use Cro::HTTP::Server;
use JSON::Class;
use Cro::HTTP::BodyParser::JSONClass;


class HelloClass does JSON::Class {
    has Str $.firstname;
    has Str $.lastname;

    method hello(--> Str ) {
        "Hello, $.firstname() $.lastname()";
    }

}

# This intermediate class is only necessary in older rakudo, as of
# 2021.09 the parameterised role can be use directly
class SomeBodyParser does Cro::HTTP::BodyParser::JSONClass[HelloClass] {
}

my $app = route {
    body-parser SomeBodyParser;
    post -> 'hello' {
        request-body -> $hello {
            content 'text/plain', $hello.hello;
        }
    }
};

my Cro::Service $service = Cro::HTTP::Server.new(:host<127.0.0.1>, :port<7798>, application => $app);

$service.start;

react  { whenever signal(SIGINT) { $service.stop; exit; } }

=end code


=begin code :lang<raku>

use Cro::HTTP::Client;
use JSON::Class;
use Cro::HTTP::BodyParser::JSONClass;

my $client1 = Cro::HTTP::Client.new: body-parsers => [Cro::HTTP::BodyParser::JSONClass[HelloClass]];
my $obj1 = await $client1.get-body: 'https://api.example.com/hello';
say $obj1.raku;
=output HelloClass.new(firstname => "fname", lastname => "lname")␤

# Setting the JSON class after creating an instance of Cro::HTTP::Client
my $body-parser = Cro::HTTP::BodyParser::JSONClass.new;
my $client2 = Cro::HTTP::Client.new: body-parsers => [$body-parser];
$body-parser.set-json-class: HelloClass;
my $obj2 = await $client2.get-body: 'https://api.example.com/hello';
say $obj2.raku;

=output HelloClass.new(firstname => "fname", lastname => "lname")␤

=end code


This provides a specialised L<Cro::BodyParser|https://cro.services/docs/reference/cro-http-router#Adding_custom_request_body_parsers> that will parse a JSON ('application/json') request body to the specified
L<JSON::Class|https://github.com/jonathanstowe/JSON-Class> type.  This is useful if you have C<JSON::Class> classes that you want to create from HTTP data, and will lead to less code and perhaps better
abstraction.


The BodyParser is implemented as a Parameterised Role with the target class as the parameter.  Because this will basically over-ride the Cro's builtin JSON parsing it probably doesn't want to be installed at the
top level in the Cro::HTTP instance, but rather in a specific C<route> block with the C<body-parser> helper, also because it is specialised to a single class it may want to be isolated to its own C<route>
block so other routes keep the default behaviour or have parsers parameterised to different classes, so you may want to do something like:


=begin code

my $app = route {
    delegate 'hello' => route {
        body-parser SomeBodyParser;
        post ->  {
            request-body -> $hello {
                content 'text/plain', $hello.hello;
            }
        }
    }
};
=end code


The test as to whether this body parser should be used (defined in the method C<is-applicable> ) is generalised to the C<application/json> content type, (hence the caveat above regarding reducing the scope.)
If you want to make a more specific test (or even if the Content-Type supplied *isn't* C<application/json>,) then you can compose this to a new class the over-rides the C<is-applicable>:


=begin code
class SomeBodyParser does Cro::HTTP::BodyParser::JSONClass[HelloClass] {
   method is-applicable(Cro::HTTP::Message $message --> Bool) {
      $message.header('X-API-Message-Type').defined && $message.header('X-API-Message-Type') eq 'Hello';
   }
}
=end code


And then use C<SomeBodyParser> in place of C<Cro::HTTP::BodyParser::JSONClass>.


The BodyParser has a C<set-json-class> method which can be used to set the C<JSON::Class> class to another class whenever needed.




role Cro::HTTP::BodyParser::JSONClass[JSON::Class $json-class? is copy] does Cro::BodyParser {
    method is-applicable(Cro::HTTP::Message $message --> Bool) {
        with $message.content-type {
            .type eq 'application' && .subtype eq 'json' || .suffix eq 'json'
        }
        else {
            False
        }
    }

    method parse(Cro::HTTP::Message $message --> Promise) {
        Promise(supply {
            my $payload = Blob.new;
            whenever $message.body-byte-stream -> $blob {
                $payload ~= $blob;
                LAST emit $json-class.from-json($payload.decode('utf-8'));
            }
        })
    }

    method set-json-class(JSON::Class $class) {
        $json-class = $class;
    }
}


JSONClass

README

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


Cro::FCGI

NAME

Synopsis

Using a network connection

Using a Unix socket

Description

Server and client host and port

Limitations

AUTHOR

License

Cro::FCGI v1.0.0

Authors

License

Dependencies

Test Dependencies

Provides

Documentation