head

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

EventSource::Server - A simple handler to provide Server Sent Events from Raku applications


This sends out an event with the DateTime string every second


=begin code
use EventSource::Server;
use HTTP::Server::Tiny;

my $supply = Supply.interval(1).map( { EventSource::Server::Event.new(type => 'tick', data => DateTime.now.Str) } );

my &es = EventSource::Server.new(:$supply);

HTTP::Server::Tiny.new(port => 7798).run(&es)

=end code


And in some Javascript program somewhere else:


=begin code

var EventSource = require('eventsource');

var v = new EventSource(' http://127.0.0.1:7798');

v.addEventListener("tick", function(e) {
    console.info(e);

}, false);
=end code


See also the examples directory in this distribution.


This provides a simple mechanism for creating a source of
L<Server Sent Events|https://www.w3.org/TR/eventsource/> in a
L<HTTP::Server::Tiny|https://github.com/tokuhirom/p6-HTTP-Server-Tiny>
server or a Cro application.


The EventSource interface is implemented by  most modern web browsers and
provides a lightweight alternative to Websockets for those applications
where only a uni-directional message is required (for example for
notifications.)


item

A Supply that provides the events, if this is not provided then the events can be
emitted onto the EventSource::Server object directly.


If this adverb is supplied then a 'keep-alive' chunk will be emitted on the stream at
the frequency specified by C<keepalive-frequency> (the default is 60 seconds.) The
"chunk" is basically a 0 byte followed by CRLF and will not cause an event in the
connected client.  This may be useful with some clients that periodically reconnect
if there is no traffic on the stream, or some reverse proxy that may disconnect
after some time with no data.


The frequency in seconds of the keepalive chunks if <keepalive> is set.  The
default is 60.


This emits an event onto the internal supplier to be merged into the C<out-supply>.


This returns the C<Supply> of C<EventSource::Server::Event> encoded as a UTF-8 Blob
which forms the event stream.  This can be passed directly to the C<content> helper of Cro
like:


content 'text/event-stream', $e.out-supply;


This calls C<done> on the C<out-supply>.  You may need to call this in an application
where a client can refresh its view thus causing a new connection to the server, however
until the previous supply is C<done> the stream will attempt to write to the now closed
connection ( leading to a "Cannot write to a closed socket" error from your application.)
This is most useful in an application which uses user session which enables tracking of
per-session event streams.



class EventSource::Server does Callable {
    class Event {
        has Str $.type;
        has Str $.data is required;
        method Str() returns Str {
            my $str = "";

            if $!type.defined {
                $str ~= "event: { $!type }\r\n";
            }
            $str ~= $!data.lines.map( -> $v { "data: $v" }).join("\r\n") ~ "\r\n\r\n";

            $str;
        }

        method encode() returns Blob {
            self.Str.encode;
        }
    }

    has Supply   $!out-supply;
    has Supply   $.supply;
    has Supplier $.supplier;
    has Promise  $!control-promise = Promise.new;
    has Int      $.keepalive-interval = 60;
    has Bool     $.keepalive;

    proto sub map-supply(|c) { * }

    multi sub map-supply(Event $e --> Event ) {
        $e;
    }

    multi sub map-supply(Str $data --> Event ) {
        Event.new(:$data);
    }

    multi sub map-supply($ (Str $type, Str $data) --> Event ) {
        Event.new(:$type, :$data);
    }

    method out-supply( --> Supply ) {
        $!out-supply //= supply {
            whenever Supply.merge(self.supplier.Supply, self.supply).map(&map-supply).map({ $_.encode }) -> $m {
                emit $m;
            }
            whenever $!control-promise {
                done;
            }
            whenever Supply.interval($!keepalive-interval) {
                if $!keepalive {
                    emit Buf(0) ~ "\r\n".encode;
                }
            }
        }
    }

    method stop( --> Nil ) {
        $!control-promise.keep
    }

    # If we weren't supplied with a Supply then
    # we just use a no-op one
    method supply( --> Supply ) {
        $!supply //= supply { };
    }

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


    method headers() {
        [
            Cache-Control   => 'must-revalidate, no-cache',
            Content-Type    => 'text/event-stream; charset=utf-8'
        ];
    }

    method CALL-ME(%env) {
        return 200, self.headers , self.out-supply;
    }
}

# vim: ft=raku


Server

Image

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

Examples for EventSource::Server

tick-server

cro-tick-server

amqp-bridge

cro-amqp-bridge

cro-json-server

EventSource::Server v0.0.11

Authors

License

Dependencies

Test Dependencies

Provides

Documentation