ARCHIV

Perl (144) - POE - událostmi řízené programování

Jak lze v Perlu psát událostmi řízené programy a co to vlastně je?

18.10.2011 00:00 | Jiří Václavík | Články autora | přečteno 10936×

POE je slovy svého autora framework pro multitasking a networking pro libovolné událostní smyčky. Znamená Perl Object Environment (nebo libovolný z dalších akronymů ze stránky poe.perl.org).

Před bližším popisem si pro navození alespoň nějaké představy vzpomeňme na používání grafických toolkitů. Zpravidla jsme vždy volali funkci s názvem mainloop nebo podobným. Ta sloužila k rozběhnutí smyčky událostí. Program vždy čekal na události od uživatele, na které vzápětí nějak reagoval.

Pojďme se na to ale podívat postupně a podrobněji.

Událost

Co je to událost? Podívejme se na pár příkladů "ze života".

• bazén je napuštěn
• voda dosáhla bodu varu
• jídlo je hotové
• autobus přijel na zastávku

Dalo by se s nadsázkou říct, že reálný svět je naprogramován právě pomocí reakcí na události. Vše má svůj důvod a vše je reakcí na nějakou událost.

Našim účelům budou blíže méně abstraktní příklady z IT života. Co může být událostí?

• start programu
• klik levým tlačítkem do určené oblasti
• stisk ENTER
• konec reakce na jinou událost

Událostmi řízené programování

Na základě emitování událostí a jejich obsluhování k tomu napsanými ovladači lze vytvořit spletitou síť, která bude něco smysluplného dělat. Pro analogii bychom opět mohli zajít do reálného světa.

Dostaneme-li na začátku programu událost _start, můžeme ji na základě okolností, vstupů atd. masivně rozvinout, přičemž nám jako programátorům stačí pouze napsat ovladače. O ostatní se postará toolkit (v našem případě POE). Naopak, vykonáno bude jen to, co je důsledkem události, která skutečně nastala. Bez událostí se žádná činnost sama neděje.

Toto paradigma se nazývá událostmi řízené programování (event-driven programming).

Událostmi řízené programování, POE a Perl

Dvěma základními součástmi POE, které budeme používat v každém programu, jsou POE::Kernel a POE::Session. Stručně řečeno, instance POE::Session jsou úkoly nebo procesy, které jsou spravovány pomocí POE::Kernel. Každý úkol má například vlastní data nebo zdroje. POE::Kernel vše řídí a rozvrhuje, kdy se má co dělat.

Vytvoření POE programu tedy zahrnuje vytvoření jednoho nebo několika úkolů (sessions), které budou obsluhovat nějaké události. Například můžeme obsloužit událost _start, která se emituje jako vůbec první událost po spuštění smyčky událostí. Existují již některé předdefinované události (první událost a poslední událost), ostatní si musíme dle potřeb nadefinovat sami.

Jak můžeme obsluhovat události? K události může (pak je obsloužena) nebo nemusí (pak je ignorována) být přiřazen ovladač. Ovladač je obyčejný podprogram, který se po vyvolání události provede.

Jakmile již není na obzoru žádná událost, úkol vyvolá událost _stop a ukončí se.

Hello World

Na úvod si ukážeme program, který bude mít jeden jednoduchý úkol - po startu vypsat text.

Vytvoříme tedy objekt typu POE::Session, kterému předáme požadované parametry. Již víme, že po spuštění smyčky událostí se emituje signál _start. Pro něj tedy napíšeme jednoduchý ovladač. Také si napíšeme ovladač pro událost _stop, která nastane těsně před zánikem POE::Session.

Po nadefinování ukolů nesmíme nikdy zapomenout spustit smyčku událostí. To provedeme voláním POE::Kernel->run.

Takto tedy bude vypadat náš první POE program.

#!/usr/bin/env perl
use strict;
use warnings;
use POE;

POE::Session->create(
    inline_states => {
        _start => sub {
            print "Hello World\n";
        },
        _stop => sub {
            print "Bye World\n";
        }
    },
);

POE::Kernel->run;

Vlastní data a vyvolávání vlastních událostí

Podívejme se na další příklad. Napíšeme si simulaci odpočítávání a startu. Schéma programu bude stejné, akorát změníme nastavení POE::Session.

Opět musíme obsloužit událost _start. Ta bude sloužit jako inicializace. Poté musíme vyvolat jinou událost, která se bude starat o odpočítávání. Nazvěme ji například countdown.

Ale popořádku. Jak tedy vyvoláme událost? Musíme zavolat metodu yield s parametrem, kterým je název události. Metodu budeme volat nad naší instancí POE::Kernel. Tu získáme jako jeden z parametrů ovladače. Nemusíme si pamatovat který, protože již máme do programu vyexportované konstanty, které toto pořadí mapují. Jinými slovy v $_[KERNEL] máme tento objekt uložen.

Druhou podstatnou věcí jsou soukromá data procesu. Ta můžeme ukládat pomocí parametru $_[HEAP] (HEAP je opět importovaná konstanta z POE), který je odkazem na datovou strukturu. My si takto uložíme počet sekund, které zbývají do startu.

Jak bude vypadat ovladač pro událost countdown? Zde musíme udělat několik věcí: Odečíst jednu sekundu, počkat a dále se zachovat podle aktuální situace. Jestliže již žádné sekundy nezbývají, došlo na start. V opačném případě opět budeme emitovat signál vyvolávající událost countdown.

Celý program může vypadat následovně.

#!/usr/bin/env perl
use strict;
use warnings;
use POE;

our $sekund = 10;

POE::Session->create(
    inline_states => {
        _start => sub {
            my $kernel = $_[KERNEL];
            my $data   = $_[HEAP];

            $data->{sekund} = $sekund;

            print "POE::Session běží\n";
            print "  Start za $sekund sekund\n";

            $kernel->yield("countdown");
        },
        _stop => sub {
            print "POE::Session končí\n";
        },
        countdown => sub {
            my $kernel = $_[KERNEL];
            my $data   = $_[HEAP];

            sleep 1;

            $data->{sekund}--;

            if($data->{sekund} > 0){
                print "  Start za " . $data->{sekund} . " sekund\n";
                $kernel->yield("countdown");
            }
            else{
                print "  Odstartováno!\n";
            }
        }
    }
);

print "POE::Kernel se spouští\n";
POE::Kernel->run;
print "POE::Kernel ukončen\n";

Zkusíme-li ho spustit, vypíše se postupně následující výstup.

$ perl start.pl
POE::Session běží
  Start za 10 sekund
POE::Kernel se spouští
  Start za 9 sekund
  Start za 8 sekund
  Start za 7 sekund
  Start za 6 sekund
  Start za 5 sekund
  Start za 4 sekund
  Start za 3 sekund
  Start za 2 sekund
  Start za 1 sekund
  Odstartováno!
POE::Session končí
POE::Kernel ukončen
$

Dodejme, že ovladači pro _stop již není poskytován parametr $_[KERNEL]. Nelze tedy již vyvolávat další signály a úkol se nekompromisně ukončí.

Multitasking

Jak si POE poradí, když chce více úkolů reagovat na tentýž signál? Co když POE::Session->create voláme vícekrát?

Nejprve bude užitečné vědět, že pomocí proměnné $_[SESSION] lze uvnitř ovladače získat proměnnou reprezentující aktuální objekt typu POE::Session. Pomocí metody ID získáme jeho jednoznačný identifikátor, který se nám bude hodit pro rozlišování mezi více úkoly.

my $session = $_[SESSION];
my $id = $session->ID;

Každý si nyní může sám zkusit připsat si vlastní POE::Session->create volání. V případě lenosti stačí zkopírovat stávající volání dvakrát (či vícekrát) po sobě (ideálně s doplněným ID do všech komentářů uvnitř ovladačů, aby bylo hezky vidět, který komentář je generovaný kterou session).

Parametry ovladačů

Metodě yield lze volitelně předat další parametry. K těm se pak uvnitř ovladače dostaneme opět přes speciální indexy, například $_[ARG0] (konstanty ARG0 až ARG9 zastupují čísla 10 až 19).

#!/usr/bin/env perl
use strict;
use warnings;
use POE;

POE::Session->create(
    inline_states => {
        _start => sub {
            my $kernel  = $_[KERNEL];
            my $session = $_[SESSION];
            print "Session " . $session->ID . " spuštěna\n";
            $kernel->yield("udalost", $session->ID);
        },
        udalost => sub {
            my $session = $_[SESSION];
            my $arg     = $_[ARG0];
            print "Session " . $session->ID . " zpracovala signál. Obdrželi jsme parametr: $arg\n";
        },
    }
);

POE::Kernel->run;

Další příklad

Zajímavou aplikací POE je modul Acme::POE::Knee, který simuluje závody poníků.

Verze pro tisk