head

Image

code

item

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

unit class Pheix::Controller::Basic;

use Pheix::View::HTML::Markup;
use Pheix::Model::Database::Access;
use Pheix::Model::JSON;
use Pheix::Model::Resources;
use Pheix::Controller::API;
use Pheix::Controller::Stats;
use Pheix::View::Debug;
use Pheix::View::Web::Headers;
use Pheix::View::Template;
use Pheix::View::Pages;
use Pheix::Addons::November::CGI;
use Pheix::Datepack;
use Pheix::Utils;
use Pheix::Test::FastCGI;

use MIME::Base64;
use OpenSSL::Digest;
use JSON::Fast;
use URI::Encode;
use FastCGI::NativeCall;
use JSON::Schema;

has Bool $.test = False;
has      %.sharedobj;
has      %.addons;
has      $.apirobj;
has      $!glbrobj;
has UInt $!maxreq = 65536;

submethod BUILD(:$apirobj!, :%addons, Bool :$test, :$mockedutils, Pheix::Model::JSON :$jsonobj) {
    my %hash  =
        apirobj => $apirobj,
        statobj => Pheix::Controller::Stats.new(:test($test // False)),
        mb64obj => MIME::Base64.new,
        dbugobj => Pheix::View::Debug.new,
        jsonobj => $jsonobj // Pheix::Model::JSON.new.set_entire_config(:addon('Pheix')),
        headobj => Pheix::View::Web::Headers.new,
        fastcgi => $test ?? Pheix::Test::FastCGI.new !! Nil,
        tmplobj => Pheix::View::Template.new,
        rsrcobj => Pheix::Model::Resources.new.init,
        mkupobj => Pheix::View::HTML::Markup.new,
        ctrlapi => Pheix::Controller::API.new,
        logrobj => Pheix::Model::Database::Access.new(
            :table('logs'), :fields(<id log>), :test($test // False)
        ),
    ;

    %hash<utilobj> = $mockedutils // Pheix::Utils.new(
        :test($test // False),
        :jsonobj(%hash<jsonobj>)
    );

    %hash<pageobj> = Pheix::View::Pages.new(
        :test($test // False),
        :tobj(%hash<tmplobj>),
        :utilobj(%hash<utilobj>),
        :headobj(%hash<headobj>),
        :jsonobj(%hash<jsonobj>),
        :rsrcobj(%hash<rsrcobj>),
        :mkupobj(%hash<mkupobj>),
        :addons(%addons)
    );

    my $schemapath = %hash<jsonobj>.get_conf_value('Pheix', 'jsonschemapath');

    if $schemapath && $schemapath.IO.f {
        %hash<validatorobj> = JSON::Schema.new(
            :schema(from-json($schemapath.IO.slurp))
        );
    }

    %!sharedobj = %hash;
    %!addons    = %addons;
    $!apirobj   = $apirobj;
    $!test      = $test // False;

}

method set_fastcgi(FastCGI::NativeCall :$fastcgi!) {
    self.sharedobj<fastcgi> = $fastcgi;
}

method userdefined(UInt :$tick, :%match!) {
    my Str $usr = %!sharedobj<pageobj>.raw_pg(
        :table(%match<params><db_name>),
        :fields(%match<params><db_flds>)
    );

    my %hdr = %!sharedobj<headobj>.header(
        %(Status => $usr ?? 200 !! 404, X-Request-ID => $tick // 1),
        List.new,
    );

    my Str $payload =
        %!sharedobj<pageobj>.show_pg(
            :pg_type($usr ?? 'debug' !! '404'),
            :pg_route(%match<details><path>),
            :pg_env(%!sharedobj<fastcgi>.env)
            :pg_content($usr // %!sharedobj<rsrcobj>.vocabulary<usrcnterror>)
    );

    %!sharedobj<fastcgi>.header(%hdr);
    %!sharedobj<fastcgi>.Print($payload);
}

method index(
    UInt :$tick,
         :%match!,
    Str  :$addon,
    Bool :$admin   = False,
         :%header  = Hash.new,
         :@cookies = List.new
) {
    my $start = now;
    my %hdr = %!sharedobj<headobj>.header(
        %(
            X-Request-ID => $tick // 1,
            %header
        ),
        @cookies,
    );

    %!sharedobj<pageobj>.set_pparams('tmpl_contentcols', $admin ?? ~12 !! ~8);
    %!sharedobj<pageobj>.set_pparams('tmpl_forcehide', $admin ?? '_phx_dnone_force' !! q{});

    srand(time);

    my $upd_captcha = sprintf "%010d", (rand * 10000000000);

    %!sharedobj<pageobj>.set_tparams('tmpl_decaptcha', $upd_captcha);
    %!sharedobj<pageobj>.set_tparams('tmpl_encaptcha', %!sharedobj<utilobj>.do_encrypt(sprintf("%s:%s", $upd_captcha, time)));

    my Str $payload =
        %!sharedobj<pageobj>.show_pg(
            :pg_addon($addon // 'Pheix'),
            :pg_type('index'),
            :pg_route(%match<details><path>),
            :pg_env(%!sharedobj<fastcgi>.env),
            :pg_match(%match)
        ) ~ %!sharedobj<pageobj>.show_rtm(:s(True), :time($start));

    %!sharedobj<fastcgi>.header(%hdr);
    %!sharedobj<fastcgi>.Print($payload);
}

method error(
    UInt :$tick,
         :%match,
    UInt :$code = 404,
    Str  :$req,
    Str  :$msg
) {
    my $start = now;
    my Str $error_code =  %match && (%match<code>:exists) ?? ~%match<code> !! ~$code;

    $error_code = '404' unless $error_code ~~ /^(400|401|402|403|404|405|413|429)$/;

    my %hdr = %!sharedobj<headobj>.header(
        %(Status => $error_code, X-Request-ID => $tick // 1),
        List.new,
    );

    my Str $payload =
        %!sharedobj<pageobj>.show_pg(
            :pg_type($error_code),
            :pg_route($req // q{/} ~ $error_code),
            :pg_content($msg // q{}),
            :pg_env(%!sharedobj<fastcgi>.env)
        ) ~ %!sharedobj<pageobj>.show_rtm(:s(True), :time($start));

    %!sharedobj<fastcgi>.header(%hdr);
    %!sharedobj<fastcgi>.Print($payload);
}

method redirect(UInt :$tick, :%match!) {
    my %envp =
        Pheix::Addons::November::CGI.new(
            :nounesc(True),
            :test($!test)
        ).params;
    if %envp<redirectto> {
        my %hdr = %!sharedobj<headobj>.header(
            %(
                Status => 302,
                Location => %envp<redirectto>,
                X-Request-ID => $tick // 1,
            ),
            List.new,
        );
        %!sharedobj<fastcgi>.header(%hdr);
    } else {
        self.error(
            :tick($tick),
            :code(404),
            :req(%match<details><path>)
        );
    }
}

method bigbrother(UInt :$tick, :%match!) {
    my %hdr = %!sharedobj<headobj>.header(
        %(X-Request-ID => $tick // 1),
        List.new,
    );

    %!sharedobj<statobj>
        .do_log(
            Pheix::Addons::November::CGI.new(
                :nounesc(True),
                :test($!test),
            )
        );

    %!sharedobj<fastcgi>.header(%hdr);
}

method logger(UInt :$tick, :%match!) {
    my %hdr = %!sharedobj<headobj>.header(
        %(X-Request-ID => $tick // 1),
        List.new,
    );

    my %res         = status => 0, msg => q{};
    my $content_len = %!sharedobj<fastcgi>.env<CONTENT_LENGTH>.UInt;

    if $content_len < $!maxreq {
        my $r   = %!sharedobj<fastcgi>.Read($content_len);
        my %req = from-json($r) // {};

        if (%req<log>:exists && %req<log>.defined) {
            my $insert_params = {
                id  => time,
                log => %!sharedobj<mb64obj>.encode-str(%req<log>, :oneline)
            };

            %!sharedobj<logrobj>.insert($insert_params);

            %res = status => 1, msg => 'data is logged';
        }
        else {
            # bad request
            %hdr<Status> = 400;
            %res<msg>    = 'bad request';
        }
    }
    else {
        # payload too large
        %hdr<Status> = 413;
        %res<msg>    = 'payload too large';
    }

    %!sharedobj<fastcgi>.header(%hdr);
    %!sharedobj<fastcgi>.Print(to-json(%res, :sorted-keys));
}

method sitemap(UInt :$tick, :%match!, Bool :$forcestatic) {
    my UInt $dynasm = %!sharedobj<jsonobj>.get_setting(
        'Pheix', 'dynasitemap', 'value', :nocache(True)
    ) || 0;

    if ($dynasm == 1 && !$forcestatic) {
        my %hdr = %!sharedobj<headobj>.header(
            %(
                Content-Type => 'text/xml; charset

',
                X-Request-ID => $tick // 1,
            ),
            List.new,
        );


UTF-8


        my Str $payload = %!sharedobj<pageobj>.show_sm;

        %!sharedobj<fastcgi>.header(%hdr);
        %!sharedobj<fastcgi>.Print($payload);
    }
    else {
        my $smfn = %!sharedobj<utilobj>.smfn;
        if $smfn.defined && $smfn.IO.e {
            my $mdtime  = $smfn.IO.modified;
            my $dateobj =
                Pheix::Datepack.new(
                    :date(Date.new($mdtime).DateTime),
                    :unixtime($mdtime.UInt),
            );
            my $fstats = $dateobj.get_http_response_date;
            my %params =
                Content-Type   => 'text/xml; charset

',
                Last-Modified  => $fstats,
                Expires        => $fstats,
                Cache-Control  => 'no-cache,no-store,max-age=0,must-revalidate',
                X-Request-ID   => $tick // 1,
            ;
            my %hdr = %!sharedobj<headobj>.header(%params, List.new);



            my Str $payload = $smfn.IO.slurp;

            %!sharedobj<fastcgi>.header(%hdr);
            %!sharedobj<fastcgi>.Print($payload);
        }
        else {
            self.error(
                :tick($tick),
                :code(404),
                :req(%match<details><path>)
            );
        }
    }
}

method api_debug(UInt :$tick, :%match!) {
    my %hdr = %!sharedobj<headobj>.header(
        %(X-Request-ID => $tick // 1),
        List.new,
    );

    my Str $payload = %!sharedobj<dbugobj>.api_debug_form(:url('/api'));

    %!sharedobj<fastcgi>.header(%hdr);
    %!sharedobj<fastcgi>.Print($payload);
}

method api(UInt :$tick, :%match!) {
    my %hdr = %!sharedobj<headobj>.header(
        %(X-Request-ID => $tick // 1),
        List.new,
    );

    my %res =
        status => 0,
        msg => 'bad API request',
        content => '<p>Bad API request</p>',
    ;

    my $content_len = %!sharedobj<fastcgi>.env<CONTENT_LENGTH>.UInt;

    if $content_len < $!maxreq {
        my $r = %!sharedobj<fastcgi>.Read($content_len);

        my %req;

        try {
            %req = self.validate_request(:$r);

            CATCH {
                default {
                    %res<content> = .message;
                }
            }
        }

        %req<route> = uri_decode(%req<route>) if %req<route>:exists;

        %res<request> = %req.gist;
        # spurt "/tmp/request.txt", %req.gist;

        if (
            (%req<credentials>:exists && %req<credentials>.defined && %req<credentials>.keys) &&
            (%req<route>:exists && %req<route>.defined) &&
            (%req<method>:exists && %req<method>.defined)
        ) {
            if $!apirobj.defined && self!tokenized_route(
                :credentials(%req<credentials>),
                :route(%req<route>),
                :method(%req<method>)
            ) {
                my $start = now;

                if (
                    (
                        %req<httpstat>:!exists ||
                        %req<httpstat> !~~ /^(400|401|402|403|404|405|413|429)$/
                    ) &&
                    my %m = %!sharedobj<apirobj>.match(%req<route>, %req<method>)
                ) {
                    my Hash $pload =
                        (%req<payload>:exists) && %req<payload>.keys ??
                            %req<payload> !!
                                {};

                    if %m<controller> ne %!sharedobj<ctrlapi>.^name {
                        my %addon_data = %!addons{%m<controller>}<objct>.get(:ctrl(self))."%m<action>"(
                            :match(%m),
                            :route(%req<route>),
                            :tick($tick),
                            :sharedobj(%!sharedobj),
                            :credentials(%req<credentials>),
                            :payload($pload),
                            :header(%hdr)
                        );

                        if (%addon_data<header>:exists) && %addon_data<header>.keys.elems > 0 {
                            %hdr = %addon_data<header>:delete;
                        }

                        %res =
                            status => 1,
                            msg => %req<route> ~ ' fetch is successful',
                            content => %addon_data
                        ;
                    }
                    else {
                        %res =
                            status => 1,
                            msg => sprintf("%s is fetched via %s.%s: %s$%s$", %req<route>, %m<controller>, %m<action>, %!sharedobj<pageobj>.sesstoken, %req<credentials><token>),
                            content => ::(%m<controller>).new(:ctrl(self))."%m<action>"(
                                :match(%m),
                                :route(%req<route>),
                                :tick($tick),
                                :sharedobj(%!sharedobj),
                                :credentials(%req<credentials>),
                                :payload($pload)
                            )
                        ;
                    }
                }
                else {
                    my $start = now;
                    %res =
                        status => 1,
                        msg => %req<route> ~ ' bad request',
                        content => %!sharedobj<ctrlapi>.error(
                            :route(%req<route>),
                            :code(%req<httpstat> // '400'),
                            :message(sprintf("API controller error: reqmsg=%s, reqcode=%s", %req<message> // q{}, %req<httpstat> // q{})),
                            :tick($tick),
                            :sharedobj(%!sharedobj),
                        )
                    ;
                }

                %res<render> = (now - $start).Str;

                CATCH {
                    default {
                        %res<content> = .message ~ .backtrace;
                        %res<msg> = (
                            'type:' ~ $!apirobj.^name ~ q{,} ~
                            'path:' ~ %req<route> ~ q{,} ~
                            'method:' ~ %req<method>
                        );
                    }
                };
            }
        }
    }
    else {
        %hdr<Status> = 400;
    }

    %!sharedobj<fastcgi>.header(%hdr);
    %!sharedobj<fastcgi>.Print(to-json(%res, :sorted-keys));
}

method api-error(UInt :$tick, :%match!) {
    my %hdr = %!sharedobj<headobj>.header(
        %(X-Request-ID => $tick // 1),
        List.new,
    );

    my %res;
    my $error_code = ~%match<code> // q{};

    if $error_code ~~ / '4' <[0..9]> ** 2..2 / {
        %res =
            status => 1,
            msg => 'request is successful',
            content => Pheix::Controller::API.new(:ctrl(self)).error(
                :%match,
                :route(sprintf("/%s", $error_code)),
                :tick($tick),
                :sharedobj(%!sharedobj),
                :message(q{})
            )
        ;
    }
    else {
        %res  =
            status => 0,
            msg => 'wrong error code',
            content => '<p>Wrong error code</p>',
        ;
    }

    %!sharedobj<fastcgi>.header(%hdr);
    %!sharedobj<fastcgi>.Print(to-json(%res, :sorted-keys));
}

method validate_request(
    Str :$r!
) returns Hash {
    my $validation =
        { status => True, error => q{}, payload => from-json($r) // {} };

    return $validation<payload> unless %!sharedobj<validatorobj>;

    try {
        %!sharedobj<validatorobj>.validate($validation<payload>);

        CATCH {
            default {
                $validation<status> = False;
                $validation<error>  = .message;
            }
        }
    }

    X::AdHoc.new(:payload($validation<error>)).throw unless $validation<status>;

    return $validation<payload>;
}

method !tokenized_route(
    Hash :$credentials!,
    Str :$route!,
    Str :$method!
) returns Bool {
    True;
}


Basic

use v6;

use NativeCall;
use NativeHelpers::CStruct;
need DBDish::Pg::Connection;



Pg::Notify - Reactive interface to PostgreSQL notifications


=begin code

use Pg::Notify;
use DBIish;

my $db = DBIish.connect('Pg', database => "dbdishtest");
my $channel = "test";

my $notify = Pg::Notify.new(:$db, :$channel );

react {
    whenever $notify -> $notification {
        say $notification.extra;
    }
    whenever Supply.interval(1) -> $v {
        say $db.do("NOTIFY $channel, '$v'");
    }
}

=end code


This provides a simple mechanism to get a supply of the PostgresQL
notifications for a single or group of channels. The supply will emit a stream
of pg-notify objects corresponding to a NOTIFY executed on the connected
Postgres database.


Typically the NOTIFY will be invoked in a trigger or other server side
code but could just as easily be in some other user code (as in the
Synopsis above,)


The objects of type Pg::Notify have a Supply method that allows coercion
in places that expect a Supply (such as whenever in the Synopsis
above.) but you can this Supply directly if you want to tap it for
instance.


method new(DBDish::Pg::Connection :$db, Str :@channel)


Both parameters are required. C<$db> should be the result of a
C<DBIish.connect> to a Postgres database,  C<@channel> should be
a list of NOTIFY topics that you want to receive.


Using multiple Pg::Notify on the same DB connection may result in
lost notifications.


This returns the Supply onto which the notifications are emitted as
they arrive, it will act as a coercer in certain places such as a
C<whenever> which expect a Supply.


The objects emitted are C<DBDish::Pg::Native::pg-notify> with the
following members:


The name of the "topic" or "channel" the notification is for.


The Process ID of the process in which the NOTIFY was executed.


The string "payload" of the notification, it is optional on the
NOTIFY command so may be undefined.  There is a limit of about
8192 Bytes on the size of the oayload. The encoding of the payload
is a function of the server configuration.


This will call UNLISTEN on the database connection and terminate
the thread that polls for new notifications, after calling this
if you want to resume listening for notifications you will need
to create a new object.



class Pg::Notify {
    has DBDish::Pg::Connection  $.db      is required;
    has Str                     @.channel is required;

    has $!thread;

    has Supplier $!supplier;

    has Promise $!run-promise;

    class PollFD is repr('CStruct') {
        has int32 $.fd;
        has int16 $.events;
        has int16 $.revents;
    }

    sub poll(PollFD $fds, int64 $nfds, int32 $timeout --> int32 ) is native { * }

    method supplier( --> Supplier ) handles <Supply> {
        $!supplier //= do {
            my $supplier = Supplier.new;
            self.listen;
            $!run-promise = Promise.new;
            $!thread = Thread.start: :app_lifetime, {
                loop {
                    $!db.pg-consume-input;

                    # Retrieve all pending notifications.
                    while $!db.pg-notifies -> $not {
                        if @!channel (cont) $not.relname {
                            $supplier.emit: $not;
                        }
                    }
					self.poll-once;
                }

                # Exceptions inside this block typically indicate some type
                # of communications issue with the database.
                CATCH {
                    default {
                        $supplier.quit($_);
                    }
                }
            }
            $supplier;
        }
    }

    method poll-once( --> Int ) {
        my $fds = LinearArray[PollFD].new(1);
        $fds[0] = PollFD.new(fd => $!db.pg-socket,  events => 1, revents => 0);
        poll($fds.base, 1, -1);
        my $rc = $fds[0].revents;
        $fds.dispose;
        $rc;
    }


    method listen() {
        for @!channel -> $channel {
            $!db.do("LISTEN " ~ $channel);
        }
    }

    method unlisten() {
        for @!channel -> $channel {
            $!db.do("UNLISTEN " ~ $channel);
        }
        if $!run-promise {
            $!run-promise.keep: True;
        }
    }
}


# vim: ft=raku ts=4 sw=4 expandtab


Notify

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

PG::Notify

image i_github_com_jonathanstowe_pg_notify_workflows_ci_badge_svg not found

Synopsis

Description

Install

Support

Copyright and Licence

Pg::Notify v0.0.7

Authors

License

Dependencies

Test Dependencies

Provides

Documentation