Ploug 2008 Cep Materialy Szkoleniowe

POLISH ORACLE USER GROUP XIV KONFERENCJA DEWELOPERÓW I UŻYTKOWNIKÓW ORACLE 14-17.X.2008 SZCZYRK

Warsztat [WP CEP]

Złożone i strumieniowe przetwarzanie zdarzeń (Complex Event Processing, Event Stream Processing)

Materiały szkoleniowe

Prowadzący: Waldek Kot

SPIS TREŚCI A.Informacje o warsztacie..............................................................................................4 a.Agenda.....................................................................................................................4 b.Profil uczestnika......................................................................................................5 c.Poziom wiedzy uczestnika......................................................................................5 d.Forma zajęć.............................................................................................................5 e.Czas trwania............................................................................................................5 f.Informacja o prowadzącym......................................................................................5 B.Szczegółowy program zajęć.......................................................................................6 C.Ćwiczenie I – Instalacja oprogramowania Oracle CEP..............................................7 D.Ćwiczenie II – Instalacja oprogramowania Eclipse IDE .........................................12 E.Ćwiczenie III – Instalacja wtyczek do Eclipse IDE, wspierających budowę aplikacji dla Oracle CEP.............................................................................................................14 F.Ćwiczenie IV – definicja domeny Oracle CEP i serwerów CEP przy użyciu Configuration Wizard...................................................................................................20 G.Ćwiczenie V – Definicja instancji serwera Oracle CEP w Eclipse..........................25 H.Ćwiczenie VI – Generacja aplikacji „Hello CEP World” w Eclipse IDE................33 I.Ćwiczenie VII – Prosta modyfikacje reguł CEP w aplikacji Hello World................40 J.Ćwiczenie VIII – Debugowanie aplikacji..................................................................41 K.Ćwiczenie IX. Modyfikacje zapytań (EPL).............................................................42 L. Ćwiczenie X. Poznajemy język EPL.......................................................................44 M.Inne, warte poznania cechy Oracle CEP..................................................................50 N. Kontakt do prowadzącego.......................................................................................59

2

Cel spotkania: Poznanie koncepcji złożonego przetwarzania strumieni zdarzeń w czasie rzeczywistym. Koncepcje ESP - Event Stream Processing, CEP - Complex Event Processing, EDA - Event-driven Architecture, ED-SOA - Event-driven Service

Oriented

Architecture.

Poznanie

zdarzeniowego

serwera

aplikacyjnego (Oracle CEP Server), nowego modelu programistycznego dla aplikacji zdarzeniowych tworzonych w Java. Poznanie jednego z języków przetwarzania zdarzeń (EPL - Event Processing Language). Podczas warsztatu pokazany będzie także przykład wspólnego wykorzystania gorących dzisiaj technologii takich jak Spring i OSGi, do budowy aplikacji zdarzeniowych.

Dlaczego warto: • Temat jest stosunkowo nowy (a dla środowiska Java bardzo nowy); •

Przetwarzanie zdarzeniowe wzbudza coraz większe zainteresowanie;

•

Dzięki zajęciom uczestnik wzbogaci swój warsztat i będzie umiał zidentyfikować,

jakie

problemy

powinno

się

rozwiązywać

przy

wykorzystaniu technologii CEP/ESP, zamiast przystosowywać do tego J2EE/JEE, technologie bazodanowe, czy silniki reguł.

3

A. Informacje o warsztacie a. Agenda 1. Przetwarzanie zdarzeniowe - a cóż to jest? i. do rozwiązania jakich problemów służy ii. specyfika tych problemów iii. porównania z innymi podejściami; 2. Przykłady wykorzystania (w tym w realnych projektach); 3. Zdarzeniowy serwer aplikacyjny i. na przykładzie Oracle CEP Server; 4. Model aplikacji przetwarzającej zdarzenia: i. główne komponenty (adaptery, strumienie, procesory zdarzeń, logika biznesowa), ii. wykorzystanie Spring, Spring-DM (dawniej Spring-OSGi) i OSGi, iii. trochę o Oracle microService Architecture (mSA); 5. Budowa prostej aplikacji typu ‘Hello Event World' i. na przykładzie Oracle CEP Server i Eclipse; 6. Język przetwarzania zdarzeń i. na przykładzie SQL-podobnego Event Processing Language (EPL), ii. przykłady bardziej złożone; 7. O persystencji, wydajności i klastrowaniu aplikacji zdarzeniowych i. na przykładzie takich technologii Oracle jak: Coherence, Berkeley DB i Times Ten; 8. O

aspektach

real-time

w

Java

(w

kontekście

przetwarzania

zdarzeniowego) i. na przykładzie Oracle JRockit Real Time JVM; 9. Ekosystem ESP i CEP (czyli jakie inne komponenty architektury zdarzeniowej warto uwzględniać. Będzie m.in. o korzyściach z połączenia koncepcji EDA i SOA, wykorzystaniu ESB, silników procesowych i BAM).

4

b. Profil uczestnika Architekci systemów, deweloperzy.

c. Poziom wiedzy uczestnika 1. Podstawowa znajomość języków Java i SQL (na poziomie zrozumienia SELECT, FROM, WHERE, GROUP BY, ORDER, HAVING, INSERT INTO,...). 2. Nie trzeba posiadać wiedzy o Eclipse, Spring, Spring-OSGi, czy OSGi (choć warto), ani o produktach Oracle middleware typu serwer aplikacyjny WebLogic Server.

d. Forma zajęć 1. warsztat, zajęcia praktyczne przy komputerach wspomagane prezentacją slajdów

oraz dyskusja. Zajęcia praktyczne obejmują instalację

oprogramowania (Oracle CEP, Eclipse), budowę prostej aplikacji zdarzeniowej, a następnie rozwijanie tej aplikacji.

e. Czas trwania 4 godziny

f. Informacja o prowadzącym Waldek Kot jest inżynierem systemowym w Oracle (wcześniej związany z BEA Systems, Eastern Europe). Zajmuje się doradzaniem Klientom w Europie Środkowej i Wschodniej w wyborze technologii middleware dla realizowanych przez nich projektów z zakresu budowy i integracji aplikacji oraz budowy rozwiązań klasy SOA, EDA i BPM. Specjalizuje się w technologiach middleware związanych z Java, J2EE/JEE oraz Spring, a także technologiach telekomunikacyjnych związanych z IMS (IP Multimedia Subsystem), takich jak SIP, SIP Servlet, czy telecom web services. Jest także aktywnym członkiem społeczności Warszawa Java User Group i Polish Java User Group.

5

B. Szczegółowy program zajęć • •

8:00 – 8:15 Rozpoczęcie zajęć 8:15 – 9:00 Prezentacja o Complex Event Processing i. co to jest złożone przetwarzanie zdarzeń i czym różni się od innych metod przetwarzania zdarzeń ii. przykłady zastosowań CEP iii. główne problemy w CEP iv. wykorzystanie wiedzy o Java i SQL v. middleware dla CEP vi. gdzie szukać więcej informacji vii. dyskusja

•

9:00 – 9:10 Przerwa

•

9:10 – 10:00 Demonstracja technologii Oracle CEP

•

10:00 – 10:10 Przerwa

•

10:10 – 11:00 Ćwiczenia praktyczne i. instalacja oprogramowania Oracle CEP ii. instalacja oprogramowania Eclipse IDE iii. instalacja wtyczki do Eclipse IDE iv. aplikacja „Hello CEP World”

•

11:00 – 11:10 Przerwa

•

11:10 – 11:45 Prezentacja technologii wchodzących w skład Oracle CEP i. język EPL (Event Processing Language) 1. podobieństwa do SQL 2. rozszerzenia w stosunku do SQL 3. dodatkowe konstrukcje a. łączenie zdarzeń z danymi z relacyjnych źródeł oraz z cache ii. Spring Framework iii. OSGi iv. Spring-DM 11:45 – 12:00 Podsumowanie i dyskusja i. Inne zagadnienia związane z budową aplikacji CEP 1. klastrowanie (High Availability) 2. wykorzystanie cache (Oracle Coherence) 3. adaptery: HTTP pub-sub, JMS, inne 4. wizualizacja 5. nagrywanie zdarzeń

•

•

12:00 – Zakończenie warsztatu

6

C. Ćwiczenie I – Instalacja oprogramowania Oracle CEP 1. Włożyć do napędu CD-ROM dołączoną do materiałów płytę CD 2. Przejść do folderu Oprogramowanie 3. Przejść do folderu OCEP i uruchomić znajdujący się w nim plik: ocep103_win32.exe 4. Ukaże się ekran powitalny, na którym należy nacisnąć przycisk Next:

5. Ukaże się ekran, w którym należy podać folder do którego zostanie zainstalowane oprogramowanie Oracle CEP. Ten folder w nomenklaturze Oracle (a wcześniej BEA), jest nazywany BEA_HOME. Na jednym komputerze z łatwością może koegzystować wiele instalacji oprogramowania Oracle WebLogic, w tym także wiele wersji. Na ekranie należy zatem: i. wybrać opcję Create a New BEA Home ii. w polu BEA Home Directory podać folder do którego zostanie zainstalowane oprogramowanie Oracle CEP

7

W tym przypadku, jako BEA Home Directory został ustawiony folder C:\OCEP103. Następnie należy nacisnąć przycisk Next. 6. Pojawi się ekran wyboru typu instalacji. Należy wybrać opcję Custom, gdyż podczas ćwiczeń będą demonstrowane przykładowe aplikacje (samples). Wybranie opcji Custom pozwoli na kolejnym ekranie dodanie przykładowych aplikacji do właśnie wykonywanej instalacji Oracle CEP. Po wybraniu opcji custom należy nacisnąć przycisk Next.

8

7. Pojawi się ekran konfiguracji instalowanych komponentów, na którym należy zaznaczyć opcję Event Server Samples. Produkt Oracle CEP trafił do oferty Oracle wraz z akwizycją firmy BEA Systems. Dawna nazwa produktu Oracle CEP, która może być wciąż używana w dokumentacji produktu, to BEA WebLogic Event Server. Powinny być zatem zaznaczone obie opcje, tj. Event Server i Event Server Samples. Następnie należy nacisnąć przycisk Next.

8. Ukaże się ekran konfiguracji środowiska Java. Nie należy na tym ekranie dokonywać żadnych zmian, a jedynie nacisnąć przycisk Next.

9

9. Pojawi się ekran konfiguracji folderu do którego zostaną zainstalowane binaria produktu Oracle CEP. Nie należy na tym ekranie nic zmieniać, gdyż wartości domyślne są w pełni akceptowalne, a jedynie nacisnąć przycisk Next.

10. Jeśli oprogramowanie Oracle CEP jest instalowane w systemie Windows, to pokaże się ekran konfiguracji skrótów w menu Start. Należy pozostawić domyślną wartość „All Users” Start Menu folder, a następnie nacisnąć przycisk Next.

10

11. Ukaże się ekran podsumowujący wybrane opcje instalacyjne. Należy nacisnąć przycisk Next.

12. Rozpocznie się instalacja oprogramowania. W zależności od szybkości napędu z którego instalowane jest oprogramowanie, proces ten potrwa 2-3 minut. Po zakończeniu instalacji, ukaże się ekran potwierdzający pomyślne zainstalowanie oprogramowania Oracle CEP. Należy nacisnąć przycisk Done.

11

D. Ćwiczenie II – Instalacja oprogramowania Eclipse IDE 1. Do tworzenia aplikacji zdarzeniowych korzystających z Oracle CEP, Oracle rekomenduje wykorzystanie środowiska deweloperskiego Eclipse IDE. Istnieje możliwość dodania do Eclipse zestawu wtyczek (plugins), ułatwiających uruchamianie aplikacji Java w środowisku Oracle CEP. Wtyczki te rozszerzają standardową instalacji Eclipse IDE 3.3.2 (Europa), bądź inne oparte o tę wersję Eclipse środowiska deweloperskiego (np. bezpłatnego Oracle Workshop 10.3, dostępnego m.in. wraz z oprogramowaniem Oracle WebLogic Server). Rozszerzenia te polegają m.in. na: i. Możliwości zdefiniowania środowiska wykonawczego (serwera), typu Oracle CEP Server i zarządzania jego instancjami, w tym startowania, stopowania, konfigurowania, uruchamiania w trybie debug, itd. bezpośrednio ze środowiska Eclipse. ii. Możliwości stworzenia szkieletu aplikacji dla Oracle CEP, wraz ze wszystkimi wymaganymi plikami konfiguracyjnymi (deployment descriptor). iii. Możliwości wizualnego podglądu oraz konfiguracji aplikacji Oracle CEP. Wtyczki te będą instalowane w kolejnym ćwiczeniu (nr III, w następnym punkcie). 2. Aby zainstalować Eclipse IDE, należy włożyć do napędu CD-ROM dołączoną do materiałów płytę CD 3. Przejść do folderu Oprogramowanie 4. Skopiować folder eclipse w dowolne miejsce na dysku twardym, np. C:\. W ten sposób powstanie folder C:\eclipse. 5. Warto utworzyć skrót na pulpicie Windows, do szybkiego uruchamiania Eclipse IDE. W tym celu należy wejść do folderu eclipse, zaznaczyć plik eclipse.exe, a następnie z menu kontekstowego wybrać opcję Utwórz Skrót. Następnie należy przenieść (lub skopiować) ten skrót na pulpit Windows. 6. Uruchamiając ten skrót, ukaże się ekran powitalny Eclipse, a następnie pytanie o domyślny folder roboczy, w którym będą składowane pliki projektowe Eclipse. Wartość domyślna czyli w Windows folder workspace w C:\Documents and Settings\ jest OK (ale można także podać inny, np. C:\workspace\ocep). Warto zaznaczyć opcję Use this as default and do not ask again, co pozwoli następnym razem na szybsze uruchamianie Eclipse i przechodzenie do właściwego projektu.

12

7. Po uruchomieniu Eclipse, należy przejść do obszaru roboczego (Workbench), wybierając zaznaczoną na poniższym rysunku ikonę:

8. Instalacja Eclipse IDE jest w ten sposób zakończona.

13

E. Ćwiczenie III – Instalacja wtyczek do Eclipse IDE, wspierających budowę aplikacji dla Oracle CEP 1. Aby rozszerzyć Eclipse IDE (lub bazujące na nim inne środowisko deweloperskie, np. Oracle Workshop), należy doinstalować wtyczki (plugins) do Oracle CEP. 2. W tym celu należy włożyć do napędu CD-ROM dołączoną do materiałów płytę CD. 3. Uruchomić (o ile nie jest jeszcze uruchomione) Eclipse IDE. 4. Z menu głównego Eclipse IDE wybrać: Help -> Software Updates -> Find and Install:

14

5. Ukaże się ekran konfiguracji uaktualnień Eclipse. Należy wybrać opcję Search for new features to install. Następnie nacisnąć przycisk Next.

6. Ukaże się ekran konfiguracji miejsc pobierania uaktualnień Eclipse, czyli miejsc (na lokalnym dysku lub zdalnych, tj. w internecie), z których można pobrać uaktualnienia (plugin’y Eclipse). W przypadku Oracle CEP, plugin do Eclipse znajduje się w folderze BEA_HOME, do którego oprogramowanie Oracle CEP zostało zainstalowane (w kroku D powyżej). Na przykład: C:\OCEP103. Na tym ekranie należy nacisnąć przycisk New Archived Site (wybieramy tę opcję, gdyż domyślnie wtyczki Oracle CEP są dostarczone w postaci pliku ZIP, w folderze BEA_HOME\ocep_10.3\eclipse-update-site (np. C:\OCEP103\ocep_10.3\eclipse-update-site). Plik ten nazywa się cep-tools-10.3.0.20080917-2044.zip.

15

7. Ukaże się ekran wyboru pliku – należy wybrać folder BEA_HOME\ocep_10.3\eclipse-update-site (np. C:\OCEP103\ocep_10.3\eclipse-update-site), a następnie znajdujący się w tym folderze plik cep-tools-10.3.0.20080917-2044.zip. 8. Ukaże się ekran z nazwą miejsca uaktualnień – domyślne wartości są poprawne, więc należy nacisnąć przycisk OK.

9. Następnie należy nacisnąć przycisk Finish 10. Ukaże się ekran konfiguracji nowej wtyczki. Należy zaznaczyć opcję obok nazwy wtyczki, potwierdzając tym samym chęć instalacji wtyczki. Następnie nacisnąć przycisk Next.

16

11. Ukaże się ekran z licencją wtyczki. Należy wybrać opcję I accept the terms in the license agreement i nacisnąć przycisk Next.

12. Ukaże się ekran konfiguracji folderu w którym wtyczka będzie zainstalowana. Nie należy na tym ekranie nic zmieniać. Wystarczy wcisnąć przycisk Finish.

17

13. Ukaże się ekran weryfikacji instalacji. Należy nacisnąć przycisk Install All:

14. Ukaże się ekran z pytaniem o zrestartowanie Eclipse. Jest to konieczne, aby nowododana wtyczka została uaktywniona w Eclipse IDE. Należy zatem nacisnąć przycisk Yes:

18

15. Po zrestartowaniu w menu Eclipse IDE ukażą siędodatkowe opcje związane z Oracle CEP. Dla przykładu, wybierając z menu głównego Eclipse opcję File -> New Project, ukaże się poniższy ekran, dzięki któremu będzie możliwe stworzenie szkieletu aplikacji zdarzeniowej dla Oracle CEP. Będziemy z tego korzystać w kolejnych ćwiczeniach.

19

F. Ćwiczenie IV – definicja domeny Oracle CEP i serwerów CEP przy użyciu Configuration Wizard 1. W terminologii Oracle CEP serwer CEP oznacza logiczny zbiór zasobów i usług CEP działających w ramach jednego procesu JVM. W ramach pojedynczego serwera może być uruchomionych dowolna liczba aplikacji zdarzeniowych. Nie należy utożsamiać serwera CEP z fizyczną maszyną (serwerem), gdyż w ramach jedej maszyny może być zainstalowanych i uruchomionych wiele serwerów CEP. 2. Natomiast przez domenę Oracle CEP rozumie się zbiór serwerów CEP zarządzanych jako jedna jednostka administracyjna. W ramach domeny może działać jeden lub więcej serwerów. Podobniej jak wcześniej, w ramach jednego fizycznego komputera może być zdefiniowanych wiele domen. Co więcej – możliwe jest równoczesne działanie wielu wersji oprogramowania Oracle CEP na jednej maszynie. 3. Dodatkowym pojęciem jest klaster serwerów CEP, który oznacza grupę serwerów CEP, które współdziałają ze sobą w celu zwiększenia skalowalności, a przede wszystkim wysokiej dostępności rozwiązania. W ramach jednej domeny CEP może być zdefiniowanych wiele klastrów. 4. Do konfiguracji domen i serwerów w ramach domen Oracle rekomenduje użycie graficznego narzędzia Configuration Wizard. Można je uruchomić w Windows z menu Start -> All Programs -> Oracle Complex Event Processing 10gR3-> Tools -> Configuration Wizard. Po wybraniu tego skrótu pokaże się następujący ekran powitalny, na którym należy nacisnąć przycisk Next:

20

5. Ukaże się ekran wybour tworzenia nowej lub rozszerzenia istniejącej domeny. Należy wybrać opcję Create a new WebLogic Event Server domain i nacisnąć przycisk Next:

6. Pokaże się ekran konfiguracji konta administracyjnego. Jako User name należy podać wlevs. Podobnie, jako hasło należy podać wlevs (w obu polach: User password, jak i Confirm user password). Następnie nacisnąć przycisk Next

21

7. Na kolejnym ekranie można skonfigurować sieciowe parametry pracy serwera, takie jak port na którym nasłuchuje ten serwer Oracle CEP (każda instancja serwera Oracle CEP powinna mieć unikalną parę hostname:port). Podane wartości domyślne są OK, należy tylko zapamiętać port na którym nasłuchuje dana instancja, gdyż parametr ten będzie później używany w kolejnych ćwiczeniach (domyślna wartość pola port to 9002). Należy nacisnąć przycisk Next.

8. Pokaże się ekran konfiguracji hasła do zasobnika z kluczami używanymi do SSL. Należy dwukrotnie podać hasło (min. 6 znaków), dla ułatwienia np. weblogic. Następnie nacisnąć przycisk Next.

22

9. Kolejny ekran pozwala zdefiniować opcjonalne źródła danych do relacyjnych baz danych dostępnych poprzez standard JDBC. Pozwala to na łączenie danych w strumieniach zdarzeń przetwarzanych przez silnik CEP, z danymi statycznymi, znajdującymi się w relacyjnych bazach danych. W niniejszym warsztacie taka funkcjonalność nie będzie jednak wykorzystywana. Należy pozostawić opcję No i nacisnąć przycisk Next:

10. Na kolejnym ekranie należy określić nazwę nowej domeny i folder, w którym pliki konfiguracyjne zostaną zapisane. Jako nazwę domeny proszę wprowadzić ploug, a jako folder pozostawić wartość domyślną (C:\OCEP10\user_projects\domains). Następnie nacisnąć przycisk Create.

23

11. Ukaże się ekran na którym będzie można śledzić przebieg procesu tworzenia domeny. Powinien on zostać zakończony komunikatem Domain created successfully !. Po tym należy nacisnać przycisk Done.

24

G.Ćwiczenie V – Definicja instancji serwera Oracle CEP w Eclipse 1. Zanim zaczniemy budowę aplikacji zdarzeniowej, należy w Eclipse zdefiniować środowisko wykonawcze (serwer Oracle CEP), wewnątrz którego ta aplikacja będzie instalowana i uruchamiana. 2. W tym celu należy przejść do zakładki Servers:

3. Jeśli zakładka ta nie jest widoczna, to należy z menu głównego Eclipse wybrać Window -> Show View -> Other, a następnie w polu wyszukiwania wpisać Servers. 4. Znajdując się wewnątrz zakładki Servers należy za pomocą prawego klawisza myszki wybrać opcję New -> Server. 5. Ukaże się ekran wyboru typu nowodefiniowanego serwera. Należy wybrać opcję Oracle -> Oracle CEP v. 10.3.0, a następnie nacisnąć przycisk Next:

25

6. Ukaże się ekran konfiguracji nowej instancji Oracle CEP Server. W polu BEA Home Directory, należy podać folder do którego oprogramowanie Oracle CEP zostało wcześniej (w Ćwiczeniu I) zainstalowane (np. C:/OCEP103):

26

7. Następnie należy zdefiniować używaną przez Oracle CEP maszynę wirtualną Java (JVM). Należy używać tego samego JVM, na którym działa serwer Oracle CEP (domyślnie, maszyna wirtualna Java – Oracle JRockit JVM - jest instalowana podczas instalacji oprogramowania Oracle CEP. Znajduje się ona w folderze BEA_HOME (np. C:\OCEP103\jrockit-R27.6.0-50-1.6.0_05). W tym celu, na tym samym ekranie konfiguracyjnym, należy kliknąć na link Installed JRE preferences:

8. Ukaże się ekran zawierający wszystkie skonfigurowane w Eclipse maszyny JVM. Aby dodać nowy JVM, używany przez Oracle CEP, należy nacisnąć przycisk Add...:

27

9. Ukaże się ekran konfiguracji nowej JVM. Należy nacisnąć przycisk Browse i wybrać folder BEA_HOME\jrockit-R27.6.0-50-1.6.0_05 (np. C:\OCEP103\jrockit-R27.6.0-50-1.6.0_05). Po wybraniu pozostałe dane zostaną automatycznie uaktualnione. Następnie należy nacisnąć dwukrotnie przycisk OK:

10. Po powrocie do ekranu konfiguracji nowej instancji serwera, z listy zainstalowanych JRE (Java Runtime Environment) należy wybrać nowododane środowisko maszyny wirtualnej jrockit-R27.6.0-501.6.0_05, a następnie nacisnąć przycisk Next:

28

11. Ukaże się ekran wyboru domeny. Za pomocą przycisku Browse należy wybrać folder zawierający domenę utworzoną wcześniej (w ramach ćwiczenia III). Należy przy tym wybrać domyślny serwer utworzony w ramach tej domeny (folder: defaultserver). Następnie nacisnąć przycisk Next.

29

12. Ukaże się ekran dodawania i usuwania projektów (aplikacji) do serwera. Dodanie projektu do serwera wiąże się z zainstalowaniem (deployment) tej aplikacji w danej instancji serwera Oracle CEP. Na tym etapie aplikacja jeszcze nie istnieje, więc należy po prostu nacisnąć przycisk Finish.

13. Skonfigurowany serwer (instancja Oracle CEP) pojawi się w zakładce Servers. Kliknięcie prawym klawiszem myszy nazwie serwera, udostępnia menu, dzięki któremu będą możliwe uruchomienie, zatrzymanie serwera, dodawanie (deployment) i usuwanie (undeployment) aplikacji, konfiguracja serwera, itp. operacje. Podobnie, uaktualnienie aplikacji (np. po wykonaniu w niej zmian) będzie się odbywać poprzez wybranie opcji Publish. O tym czy konieczne jest uaktualnienie wersji aplikacji na serwerze, decyduje komunikat w kolumnie Status. Wartość Republish oznacza, iż konieczne jest uaktualnienie aplikacji. Wartość Synchronized oznacza, iż wersja aplikacji na serwerze i tej w Eclipse IDE jest identyczna.

30

14. Aby uruchomić serwer należy wybrać opcję Run::

31

15. Komunikaty z konsoli serwerowej serwera Oracle CEP są w Eclipse wyświetlane w zakładce Console. O tym, że serwer wystartował poprawnie, świadczy komunikat <Server STARTED>:

32

H. Ćwiczenie VI – Generacja aplikacji „Hello CEP World” w Eclipse IDE 1. Na tym etapie środowisko deweloperskie i uruchomieniowe Oracle CEP zostało w pełni skonfigurowane. Można zatem przystąpić do budowania aplikacji zdarzeniowych, korzystających z CEP. 2. Zanim zacznie się budować własne aplikacje, warto zapoznać się z przykładową aplikacją typu „Hello World”. Dzięki temu, na bardzo prostym przykładzie będzie możliwe poznanie typowej struktury aplikacji CEP, jej komponentów i zależności pomiędzy nimi. Możliwe także będzie opanowanie sposobu uruchamiania aplikacji i jej debugowania. 3. Wtyczki do Eclipse instalowane w Ćwiczeniu III dodają do Eclipse generatoru szkieletu aplikacji dla Oracle CEP, w tym także wygenerowanie kodu źródłowego przykładowych aplikacji. Taka wygenerowana aplikacja jest w pełni gotowa do uruchomienia, eksperymentowania i dalszego rozwoju. 4. Aby wygenerować szkielet nowej aplikacji Oracle CEP, należy z menu głównego Eclipse wybrać File -> New -> Project, a następnie z listy typów projektów (aplikacji) wybrać Oracle CEP Application Project i nacisnąć przycisk Next:

5. Wyświetli się ekran tworzenia nowej aplikacji Oracle CEP, należy podać nazwę projektu (np. ploug01) i nacisnąć przycisk Next:

33

6. Następny ekran pozwala na wprowadzenie metadanych OSGi, które zostaną umieszczone w pliku MANIFEST.MF tej aplikacji (co to jest OSGi, itd. będzie omówione później). Domyślne wartości na tym ekranie są OK, więc należy nacisnąć przycisk Next:

7. Kolejny ekran pozwala określić szablon przykładowej aplikacji, z którego będzie wygenerowana nowotworzona aplikacja. Szablon taki obejmuje kod źródłowy (Java) i pliki konfiguracyjne aplikacji (XML). Aplikacja wygenerowana z takiego szablonu jest w pełni gotowa do natychmiastowego uruchomienia.

34

Na tym ekranie należy zaznaczyć opcję Create an Oracle CEP Application using one of the templates oraz zaznaczyć szablon Hello World. Następnie należy nacisnąć przycisk Finish:

8. Aplikacja zostanie wygenerowana i wyświetli się jej domyślny EPN (Event Processing Network) – diagram pokazujący zdefiniowane komponenty aplikacji (adaptery, procesory, obiekty i strumienie). Z najważniejszych na tym etapie elementów - po lewej stronie znajdują się w postaci hierarchicznej: i. Kod źródłowy (klasy Java) – folder src ii. Pliki konfiguracyjne (pliki XML i MANIFEST.MF) – folder META-INF

35

9. Aby uruchomić tę aplikację, należy przejść na zakładkę Servers i uruchomić serwer CEP (o ile nie jest już uruchomiony – pole State powinno zawierać wartość Started), a następnie klikając prawym klawiszem myszy na nazwę serwera (Oracle CEP v10.3.0), wybrać opcję Add and Remove Projects...:

10. Wyświetli się ekran dodawania (instalacji, deployment’u) i usuwania (de-instalacji, undeployment’u) aplikacji z danej instancji serwera Oracle CEP. Należy zaznaczyć projekt (ploug01), a następnie nacisnąć klawisz Add. Nazwa projektu powinna teraz przejść z sekcji Available Projects do sekcji Configured Projects. Następnie należy nacisnąć przycisk Finish:

36

11. Aplikacja została zmodyfikowana i jest gotowa do zainstalowania na serwerze, z tym, że należy jeszcze odświeżyć konfigurację serwera (uaktualnić serwer). W tym celu należy kliknąć prawym klawiszem myszy na nazwę serwera (pod którą powinna znajdować się nazwa aplikacji ploug) i z menu wybrać opcję Publish. Pole Status w serwerze powinno zmienić się z Republish na Synchronized. 12. Publikacja aplikacji automatycznie uruchamia tę aplikację, co można zaobserwować w Eclipse w postaci komunikatów pojawiających się na konsoli (zakładka Console). Domyślnie jest to komunikat Message: HelloWorld – the current time is:xx:yy:zz. Wartość xx:yy:zz to aktualny czas. Średnio pojawia się około 3 komunikatów na sekundę (jeden komunikat jest generowany co 300 ms). 13. Rekomendacja: ponieważ komunikaty z przykładowej aplikacji są wyświetlane w sposób ciągły na konsoli (zakładka Console), to blokuje to w Eclipse możliwość przejścia do innych zakładek w danej grupie. Dotyczy to zwłaszcza zakładki Servers. Warto jest zatem przenieść (drag & drop) zakładkę Servers, to innej grupy zakładek. Na przykład tak, jak poniżej:

14. Typowa aplikacja Oracle CEP składa się z następujących komponentów (jednego lub więcej): i. Obiekt zdarzenia – klasa Java opisująca zdarzenie. Posiada atrybuty (np. jeśli zdarzenie opisuje transakcję na giełdzie papierów wartościowych, to przykładowymi atrybutami byłyby symbol akcji, cena transakcji, wolumen transakcji, czas zakupu, itd.). Obiekty zdarzeń są przesyłane w ramach sieci EPN – zwykle: od adapterów poprzez procesory do obiektów użytkownika. ii. Adapter – jest opcjonalny. Zwykle jest punktem wejścia lub wyjścia aplikacji zdarzeniowej. Zajmuje się przetworzeniem zewnętrznych zdarzeń na postać oczekiwaną przez CEP. W 37

iii.

iv.

v. vi.

vii.

viii.

praktyce adapter przekształca zewnętrzne zdarzenia (komunikaty) na obiekty Java – obiekty zdarzeń (obiekty te są POJO – Plain Old Java Objects). W przypadku aplikacji HelloWorld adapter zajmuje się nie tyle przekształcaniem zewnętrznych zdarzeń, co generowaniem zdarzeń – generuje 1 zdarzenie HelloWorld domyślnie co 300 ms i wysyła je do procesora CEP (zgodnie z konfiguracją sieci EPN). Oracle CEP zawiera kilka wbudowanych adapterów (np. pobierający dane z kolejek JMS). Dodatkowo można zbudować własne adaptery, w postaci kodu Java. Procesor – zajmuje się wykonywaniem zapytań CEP. Zapytania te są wykonywane w sposób ciągły (continousu query). Zapytania te są w postaci bazującego na SQL języku i są określone w konfiguracji aplikacji CEP. Jeśli zapytanie zwróci wynik, to jest on przekazywany do następnego elementu w EPN (zdefiniowanego jako listener danego procesora). Zwracany wynik ma formę obiektu zdarzenia. Obiekt użytkownika – zwykle jest punktem końcowym („wyjściem”) aplikacji zdarzeniowej. Jest to kod użytkownika, zwykle wykonywany w wyniku pojawienia się zdarzeń. Kod ten ma formę klasy Java (POJO) Event bean lub Spring bean – obiekt Java, który pośredniczy w przetwarzaniu zdarzeń i wykonuje zdefiniowaną logikę biznesową. Jest opcjonalny. Strumień – jest to łącznik pomiędzy komponentami w aplikacji zdarzeniowej, który określa komponent źródłowy („nadawcę” zdarzeń, source) od komponentów docelowych („odbiorców” zdarzeń, listeners). Strumień posiada także dodatkowe cechy, np. możliwość buforowania komunikatów (przydatne gdyby szybkość odbierania komunikatów była mniejsza niż szybkość ich produkowania), czy sterowanie wielowątkowością i asynchronicznością w aplikacji Konfiguracja – pliki XML. Pliki te znajdują się w folderze META-INF i są zgrupowane w dwóch folderach: • \spring – tutaj znajduje się definicja sieci EPN (Event Processing Network), która określa z jakich komponentów składa się aplikacja, jak są one skonfigurowane i jakie są między nimi relacje (w tym który element jest źródłem, a który odbiorcą zdarzeń przepływających przez sieć EPN) • \wlevs – tutaj znajduje się szczegółowa konfiguracja poszczególnych komponentów aplikacji W każdym z tych folderów może znajdować się wiele plików konfiguracyjnych XML. Przed uruchomieniem aplikacji wszystkie one scalone do jednej konfiguracji danej aplikacji. Dokument Manifest – plik MANIFEST.MF, opisujący dodatkowe metadane aplikacji, zwłaszcza zależności dotyczące OSGi (każda aplikacja Oracle CEP jest bundle OSGi).

38

15. Poniżej pokazane są miejsca w przykładowej aplikacji, w których można odnaleźć poszczególne komponenty:

ADAPTER

OBIEKT ZDARZENIA

OBIEKT UŻYTKOWN

EP N

KONFIG. EPN KONFIG. KOMPONENTÓ W

39

I. Ćwiczenie VII – Prosta modyfikacje reguł CEP w aplikacji Hello World 1. W niniejszym ćwiczeniu zostaną wprowadzone proste modyfikacje do przykładowej aplikacji Hello World, wygenerowanej w poprzednim ćwiczeniu. Ćwiczenie ma zaprezentować sposób uaktualniania aplikacji na serwerze CEP. 2. W tej chwili w wygenerowanej aplikacji adapter generuje nowy komunikat co 300 ms. W niniejszym ćwiczeniu czas te będzie zmodyfikowany na 1 sekundę. 3. W Eclipse, w zakładce Project Explorer przejść do folderu ploug01 -> src -> com.bea.wlevs.adapter.example.helloworld i dwukrotnie kliknąć na elemencie HelloWorldAdapter.java. 4. Wyświetli się kod źródłowy adaptera. Należy zmodyfikować wartość stałej SLEEP_MILLIS z 300 na 1000. Jest to wartość opóźnienia w pętli while wykonywanej w metodzie run() klasy adaptera.

5. Następnie, należy kliknąć prawym klawiszem myszy w zakładce Servers na nazwę serwera i wybrać opcję Publish. Zmianę w działaniu aplikacji można zaobserwować w zakładce Console.

40

J. Ćwiczenie VIII – Debugowanie aplikacji 1. Debugowanie aplikacji jest możliwe po uruchomieniu serwera w trybie Debug. W tym celu, należy przejść do zakładki Servers, kliknąć prawym klawiszem myszy na nazwę serwera i wybrać opcję Debug. Jeśli serwer CEP był wcześniej uruchomiony w trybie normalnym (non-debug), to nastąpi restart serwera (pole State zmieni się na Debug). 2. Możliwe jest teraz korzystanie z funkcjonalności debugowania aplikacji, udostępnianych przez Eclipse, np. zakładania punktów zatrzymań (breakpoints), podglądu aktualnego stanu zmiennych, itp. 3. Na przykład, w Project Explorer poprzez dwukrotne kliknięcie na com.bea.wlevs.example.helloworld.HelloWorldBean.java. Zostanie wyświetlony kod źródłowy tej klasy, a następnie dwukrotnie klikając na prawym marginesie tak jak na podanym poniżej ekranie, zostanie ustawiony breakpoint. Po uruchomieniu aplikacji, zostanie ona zatrzymana w podanym punkcie.

41

K. Ćwiczenie IX. Modyfikacje zapytań (EPL) 1. Kolejna prosta modyfikacja przykładowej aplikacji Hello World będzie polegała na zmianie reguł (czyli zapytań w opartym na SQL języku EPL). Dzięki temu przykładowa aplikacja będzie przetwarzać zdarzenia w inny sposób (będzie „nasłuchiwać” pojawienia się innej korelacji zdarzeń). 2. Reguły EPL są zdefiniowane w pliku konfiguracyjnym config.xml w folderze META-INF\wlevs. Należy otworzyć ten plik. Na poniższym ekranie zostało zaznaczone przykładowe zapytanie dla nowoutworzonej aplikacji Hello World, czyli będzie ono zwracało w wyniku każde zdarzenie typu HelloWorldEvent pojawiające się na wejściu procesora helloWorldProcessor:

3. Można zauważyć, iż, w porównaniu do języka SQL: i. zamiast nazw tabel, w klauzuli FROM, używa się nazw strumieni (typów zdarzeń) ii. zamiast nazw kolumn, po klauzuli SELECT używa się nazw atrybutów zdarzenia (* oznacza wybór wszystkich atrybutów zdarzenia). Zdarzenie HelloWorldEvent ma jeden atrybut message. iii. dostępne jest dodatkowe słowo kluczowe RETAIN, które zawęża analizę zdarzeń – tworzy „okno” poprzez które strumień zdarzeń jest analizowany. W podanym przykładzie to okno (RETAINS 1 EVENT) obejmuje 1 zdarzenie. Okna mogą być ilościowe (określona liczba zdarzeń, n EVENTS) lub czasowe (określony przedział czasowy, np. 10 MINUTES, 1 42

SECOND, 24 HOURS, itd). Okna mogą być „płynące” (sliding) lub „skaczące” (batching). Okna płynące są domyślnie używane. Okna skaczące definiuje się za pomocą klauzuli BATCH OF, np.: SELECT * FROM HelloWorldEvent RETAIN BATCH OF 5 SECONDS Dokładny opis rozszerzeń do SQL związanych ze złożonym przetwarzaniem zdarzeń można znaleźć w dokumentacji produktu Oracle CEP (EPL Reference Guide). 4. Proszę zmodyfikować aktualną regułę na podaną powyżej regułę korzystającą ze skaczących okien (czyli klauzuli RETAIN BATCH OF). Po modyfikacji należy uaktualnić aplikację na serwerze (czyli użyć opcji Publish) z menu kontekstowego dla serwera (zakładka Servers). Jaki efekt można zaobserwować na konsoli. Dlaczego taki ? 5. OPCJONALNIE: Kolejna drobna modyfikacja reguły, zademonstruje użycie klauzuli ORDER BY (znanej także w SQL). Zdarzenia znajdujące się w 5-sekundowym oknie czasowym, zostaną posortowane malejąco wg zawartości atrybutu message (proszę zwrócić uwagę, że atrybut message jest zdefiniowany w klasie HelloWorldEvent w pakiecie com.bea.wlevs.event.example: SELECT * FROM HelloWorldEvent RETAIN BATCH OF 5 SECONDS ORDER BY message DESC 6. OPCJONALNIE: Język EPL pozwala kontrolować w jaki sposób (w tym jak szybko) będą zwracane wyniki z zapytań. Pozwala na to klauzula OUTPUT. Poniższy przykład demonstruje jej użycie SELECT * FROM HelloWorldEvent RETAIN BATCH OF 5 SECONDS ORDER BY message DESC OUTPUT LAST 2

43

L. Ćwiczenie X. Poznajemy język EPL 1. Aby zademonstrować bardziej ciekawe możliwości języka przetwarzania zdarzeń (EPL), konieczne jest wprowadzenie rozszerzeń do aplikacji Hello World: i. dodanie atrybutów do zdarzenia HelloWorldEvent i metody toString(), dzięki której ładniej będą wyświetlane zdarzenia na konsoli. ii. modyfikację kodu użytkownika (klasa HelloWorldBean), polegającą na skorzystaniu z metody toString() wprowadzonej do klasy HelloWorldEvent iii. modyfikację sposobu generowania zdarzeń, czyli adaptera (klasa HelloWorldAdapter) iv. modyfikację reguł EPL dla procesora HelloWorldProcessor 2. Dodatkowe atrybuty dla zdarzenia HelloWorldEvent: i. Należy otworzyć kod źródłowy klasy HelloWorldEvent.java ii. Bezpośrednio pod atrybutem message należy dodać dwa nowe atrybuty: • private String symbol; • private double price; • private long volume; iii. Nowa wersja zdarzenia HelloWorldEvent będzie opisywać prostą transakcję kupna akcji (waloru), która składa się odpowiednio z symbolu waloru, ceny zakupu waloru i wolumenu (liczby kupowanych akcji po danej cenie). iv. Klasa HelloWorldEvent jest POJO i powinna zostać uzupełniona o odpowiednie getter’y i setter’y. Możemy tutaj skorzystać z funkcjonalności generowania przez Eclipse tych metod. Należy w edytorze kodu Java, w dowolnym miejscu kliknąć prawym klawiszem myszki i z menu wybrać opcję Source -> Generate Getters and Setters (można także skorzystać ze skrótu klawiszowego SHIFT+ALT+S, potem R). Na wyświetlonym ekranie należy nacisnąć klawisz Select All i nacisnąć OK. Proszę zauważyć, że w kodzie klasy HelloWorldEvent pojawiły się dodatkowe metody getSymbol, setSymbol, itd. v. Podobnie, należy uzupełnić klasę HelloWorldEvent o metodę toString(), dzięki której będzie możliwe m.in. sterowanie, w jaki sposób dane o zdrarzeniu będą wyświetlane na konsoli. Tutaj także skorzystamy ze wsparcia dawanego przez Eclipse i generacji szkieletu tej metody. Należy w edytorze kodu Java, w dowolnym miejscu kliknąć prawym klawiszem myszki i z menu wybrać opcję Source -> Override/Implement Methods (można także skorzystać ze skrótu klawiszowego SHIFT+ALT+S, potem V). Na wyświetlonym ekranie należy zaznaczyć opcję toString() i nacisnąć OK. Proszę zauważyć, że w kodzie klasy HelloWorldEvent pojawiła się metoda

44

toString, wraz z przykładową implementacją. Tę implementację należy zmienić na podaną poniżej: return "Zdarzenie ! " + new Date() + ", " + this.symbol + ", " + this.price + ", " + this.volume; Pojawi się błąd kompilacji, gdyż należy najpierw zaimportować klasę Date. Aby ten problem rozwiązać, należy nacisnąć klawisze CTRL+1 i wybrać opcję Import ‘Date’ (java.util). Błąd zniknie, a w kodzie źródłowym klasy, na początku, pojawi się deklaracja: import java.util.Date. 3. Trzeba także nieznacznie zmodyfikować klasę użytkownika HelloWorldBean. W aplikacji Hello World, metoda onEvent tej klasy jest wykonywana za każdym razem, gdy procesor zapytanie zdefiniowane w HelloWorldProcessor zwróci wynik. Wynika to z tego, iż w sieci EPN (plik META-INF\spring\helloworld.context.xml), klasa HelloWorldBean jest zadeklarowana jako odbiorca (listener) zdarzeń, wpływających do strumienia helloWorldOutstream. Źródłem (source) zdarzeń dla tego strumienia jest właśnie procesor HelloWorldProcessor. Graficznie pokazuje to także przeglądarka EPN Viewer, dostępna poprzez najechanie kursorem myszy na nazwę aplikacji w Project Explorer (ploug01), a następnie wybranie z menu kontekstowego opcji Open EPN Viewer. Modyfikacja klasy HelloWorldBean będzie polegać na zakomentowaniu 4 linii począwszy od linii if(event instance..., a następnie dodaniu pod tymi zakomentowanymi liniami nowego kodu Java (poniżej zaznaczonego czcionką pogrubioną). Cała treść nowej wersji metody onEvent została przedstawiona poniżej: for (Object event : newEvents) { //if (event instanceof HelloWorldEvent) { //HelloWorldEvent helloWorldEvent = (HelloWorldEvent) event; //System.out.println("Message: " + helloWorldEvent.getMessage()); //} System.out.println(event.toString()); }

4. Należy zapisać zmiany. Dla pewności, iż wprowadzone zmiany są poprawne, należy uaktualnić serwer (Publish) i sprawdzić wyniki na konsoli. 5. Komunikaty pojawiajce się w konsoli na tym etapie ćwiczenia pokazują, że zdarzenia mają te same atrybuty symbol, price i volume. Aby zróżnicować zdarzenia, należy zmodyfikować kod generujący zdarzenia w adapterze. W tym celu należy otworzyć kod źródłowy klasy HelloWorldAdapter i odnaleźć metodę generateHelloMessage. W tej metodzie bezpośrednio pod linią: event.setMessage(message); należy dodać następujący kod: Random r = new Random(); event.setSymbol("ORCL"); event.setPrice(10.0 + 10.0*r.nextInt(9)); event.setVolume(1000 + 1000*r.nextInt(9)); 45

6. Jeśli pojawi się błąd kompilacji, to należy użyć poprzednio poznanej metody rozwiązywania problemów czyli skrótu klawiszowego CTRL+1 lub użyć opcji automatycznej organizacji importowanych klas (skrót klawiszowy SHIFT+CTRL+O, a następnie zapisać zmiany CTRL+S i opublikować zmiany (Publish). 7. Teraz możliwe jest eksperymentowanie z trochę bardziej złożonymi regułami EPL niż poprzednio. 8. Filtrowanie zdarzeń poprzez użycie klauzuli WHERE. Przykłady: SELECT * FROM HelloWorldEvent WHERE price > 60 SELECT * FROM HelloWorldEvent WHERE price BETWEEN 50 AND 70 SELECT * FROM HelloWorldEvent WHERE price * volume > 300000 9. Możliwe jest także użycie zagnieżdżonych zapytań (subqueries): SELECT * FROM (SELECT * FROM HelloWorldEvent WHERE price > 50 ) SELECT * FROM (SELECT * FROM HelloWorldEvent WHERE price > 30 ) WHERE volume > 5000 10. Poznawanie kolejnych, bardziej złożonych możliwości języka EPL będzie ponownie wymagało wprowadzenia drobnych zmian do przykładowej aplikacji. Zostanie wprowadzony nowy typ zdarzenia NewHelloWorldEvent. W tym celu należy w Project Explorer zaznaczyć klasę HelloWorldEvent, a następnie skopiować ją (użyć: menu kontekstowe i opcja Copy albo skrót klawiszowy CTRL+C). Następnie wkleić do tego samego folderu skopiowaną klasę. Czyli ponownie użyć menu kontekstowego i opcji Paste albo skrótu klawiszowego CTRL+V. Pojawi się pytanie o nazwę nowej klasy (duplikatu) – należy wprowadzić NewHelloWorldEvent. Dwukrotnie klikając na nową klasę, otworzy się jej kod w edytorze. Pod atrybutem volume, należy dodać nowy atrybut: private double metric;

46

a następnie dodać getter/setter (SHIFT+ALT+S, potem R, zaznaczyć metric i nacisnąć przycisk OK). Dodatkowo, trzeba zmodyfikować metodę toString, tj. dodać na końcu (po: ... + this.volume;): + ”, ” + this.metric; Czyli cały kod metody toString powinien wyglądać następująco: return "Zdarzenie ! " + new Date() + ", " + this.symbol + ", " + this.price + ", " + this.volume + ", " + this.metric; 11. Niniejsze reguły demonstrują w jaki sposób w EPL możliwe jest utworzenie nowego strumienia zdarzeń, a także użycie grupowania zdarzeń (klauzula GROUP BY) i funkcji statystycznych (np. AVG, SUM, COUNT, MIN, MAX, MEDIAN, STDDEV, AVEDEV, TREND). Proszę także zwrócić uwagę, że nowe zdarzenie jest typu NewHelloWorldEvent (czyli klasa utworzona w poprzednim punkcie). Wartości atrybutów symbol, price, volume tego nowego zdarzenia zostają skopiowane z atrybutów zdarzenia HelloWorldEvent, a jako wartość atrybutu metric nowego zdarzenia będzie przyjęta wartość funkcji statystycznej (policzona dla tylu zdarzeń ile jest w zdefiniowanym oknie). Pogrubioną czcionką zaznaczono nową, interesującą cechę. Wyniki można obserwować na konsoli. INSERT INTO NewHelloWorldEvent SELECT symbol, price, volume, AVG(price) AS metric FROM HelloWorldEvent RETAIN 2 EVENTS GROUP BY symbol INSERT INTO NewHelloWorldEvent SELECT symbol, price, volume, AVG(price) AS metric FROM HelloWorldEvent RETAIN BATCH OF 2 EVENTS GROUP BY symbol INSERT INTO NewHelloWorldEvent SELECT symbol, price, volume, STDDEV(price) AS metric FROM HelloWorldEvent RETAIN 10 EVENTS GROUP BY symbol INSERT INTO NewHelloWorldEvent SELECT symbol, price, volume, AVG(price) AS metric FROM HelloWorldEvent RETAIN 3 EVENTS GROUP BY symbol HAVING AVG(price) > 30

47

INSERT INTO NewHelloWorldEvent SELECT symbol, price, volume, AVG(price) AS metric FROM HelloWorldEvent RETAIN 5 EVENTS GROUP BY symbol HAVING TREND(price) >= 2 OR TREND(price) <= -2 12. Poniższe reguły demonstrują wykrywanie wzorców w strumieniu zdarzeń przy wykorzystaniu klauzuli MATCHING. Przykłady: SELECT a MATCHING a:=HelloWorldEvent(price > 20) FOLLOWED BY HelloWorldEvent(volume = a.volume) SELECT a.symbol, a.price, a.volume, b.price, b.volume MATCHING a:=HelloWorldEvent(price > 20) FOLLOWED BY b:=HelloWorldEvent(volume = a.volume) WITHIN 10 SECONDS SELECT a.symbol, a.price, a.volume, b.price, b.volume MATCHING EVERY a:=HelloWorldEvent(price > 20) FOLLOWED BY EVERY b:=HelloWorldEvent(volume = a.volume) WITHIN 10 SECONDS 13. Opcjonalnie: Wykorzystanie własnych funkcji w EPL jest także możliwe. Wystarczy utworzyć nową publiczną klasę zawierającą statyczne publiczne metody, a następnie w regule odwołać się do tych metod. W Eclipse tworzenie nowej klasy wykonuje się poprzez wybranie z menu kontekstowego New -> Class. Wyświetli się okno tworzenia nowej klasy, należy podać pakiet w którym będzie ona utworzona i nazwę klasy. Na przykład: i. Package: com.bea.wlevs.example.custom ii. Class: MyClass Wewnątrz tej klasy należy utworzyć nową metodę, np.: public static double myFunction(double x) { return x / 10; } Przykładowy sposób użycia własnej funkcji w regułach EPL: INSERT INTO NewHelloWorldEvent SELECT symbol, price, volume, com.bea.wlevs.example.custom.MyClass.myFunction( AVG(price)) AS metric FROM HelloWorldEvent RETAIN 5 EVENTS

48

GROUP BY symbol

49

M.Inne, warte poznania cechy Oracle CEP Oracle CEP zawiera znacznie więcej ciekawej funkcjonalności, której z racji ograniczonego czasu warsztatu prowadzący nie zdołał zademonstrować. Poniżej znajduje się lista tematów, które warto poznać w toku dalszej przygody z Oracle CEP: 1. możliwość ograniczenia zdarzeń do tylko tych które wchodzą do okna (klauzula ISTREAM) lub tych, które okno opuszczają (RSTREAM), np.: SELECT RSTREAM * FROM HelloWorldEvent RETAIN 30 SECONDS 2. możliwość przetwarzania wielu strumieni zdarzeń i ich łączenia (join). i. w EPL, po klauzuli FROM może występować wiele nazw strumieni (typów zdarzeń) ii. złączenia strumieni typu inner join tworzy się z wykorzystaniem klauzuli WHERE, np. SELECT * FROM StrumienX x, StrumienY y WHERE x.symbol = y.symbol iii. dostępne są także złączenia typu LEFT, RIGHT i FULL OUTER JOIN 3. możliwość łączenia zdarzeń z danymi w tabelach RDBMS – w EPL po klauzuli FROM możliwe jest podanie nazwy bazy danych w RDBMS i zapytania SQL wykonywanego na tej bazie. Wyniki tego zapytania będą złączone z zapytaniem EPL, np.: SELECT custId, cust_name FROM CustomerCallEvent, MyCustomerDB (' SELECT cust_name FROM Customer WHERE cust_id = ${custId} ') RETAIN 10 MINUTES

Czyli: dla każdego zdarzenia w strumieniu CustomerCallEvent będzie wykonane zapytanie do bazy danych, połączenie do której zdefiniowane jest w JDBC data source MyCystomerDB. Ten data source definiuje się w pliku config.xml serwera CEP: folder-domeny/nazwa-serwera-CEP/config/config.xml np. C:\OCEP103\user_projects\domains\jdd01\defaultserver\config W podanym zapytaniu pokazano także, w jaki sposób parametryzuje się zapytanie SQL i łączy z danymi w zdarzeniu (atrybut custId) 4. możliwość łączenia zdarzeń z danymi w cache – Oracle CEP pozwala zdefiniować w sieci EPN komponent typu cache (bufor), a także zewnętrzne systemy cache. Podobnie jak dla RDBMS, możliwe jest łączenie zdarzeń z danmi w cache. Po klauzuli FROM możliwe jest podanie nazwy cache. Dane z cache będą pobierane (pull) z cache, gdy reguła EPL zwróci dane. Wraz z Oracle CEP dostarczany jest czołowe

50

rozwiązanie klasy „distributed in-memory data grid” – Oracle Coherence. 5. parametryzowanie komponentów aplikacji – możliwe jest przekazywanie z poziomu konfiguracji (META-INF\spring\*.xml) parametrów dla adapterów, beanów i innych komponentów EPN. Dla przykładu adapter HelloWorldAdapter z aplikacji Hello World można w następujący sposób rozszerzyć i. do klasy HelloWorldAdapter dodać atrybut: private String symbol; ii. wygenerować dla tego atrybutu getter/setter iii. w metodzie GenerateHelloMessage zastąpić linię: event.setSymbol(”ORCL”); przez: event.setSymbol(this.symbol); iv. w pliku konfiguracyjnym \spring\helloworld.context.xml wewnątrz elementu <wlevs:adapter> dodać następujący element: <wlevs:instance-property name="symbol" value="ORCL" /> 6. więcej niż jeden komponent danego rodzaju w EPN – w ramach sieci EPN możliwe jest zadeklarowanie więcej niż jednego komponentu danego rodzaju (np. dwóch adapterów, kilku procesorów, itd.). Dla przykładu – zakładając wykonanie punktu 6 powyżej – możliwe jest zadeklarowanie dwóch adapterów generujących zdarzenie typu HelloWorldEvent, z tym, że każdy z tych adapterów będzie generował inną wartość atrybutu symbol (np. „ORCL” i „BEA”). W tym celu należy: i. w pliku \spring\helloworld.context.xml dodać nowy (np. zduplikować istniejący) element <wlevs:adapter> ii. zmienić identyfikator (atrybut id) obu adapterów, np na: • helloWorldAdapterORCL • helloWorldAdapterBEA iii. zmienić wartość (atrybut value) elementu <wlevs:instanceproperty> o nazwie symbol: • w helloWorldAdapterORCL: value=”ORCL” • w helloWorldAdapterORCL: value=”BEA” iv. każdy z adapterów będzie poprzez oddzielny strumień zasilał zdarzeniami procesor helloWorldProcessor. W tym celu należy dodać nowy strumień (np. poprzez skopiowanie strumienia helloWorldInstream), tak, aby istniały dwa strumienie, których odbiorcą (listener) jest procesor helloWorldProcessor. Nazwać każdy z tych strumieni w unikalny sposób, np.: • helloworldInstreamORCL • helloworldInstreamBEA Następnie zmodyfikować element <wlevs:source> każdego z tych strumieni: • w helloworldInstreamORCL na: ref=”helloWorldAdapterORCL” • w helloworldInstreamBEA na:

51

ref=”helloWorldAdapterBEA” Należy się upewnić, że element <wlevs:listener> odnosi się do helloWorldProcessor. Po aktualizacji aplikacji i jej uruchomieniu, w konsoli można zaobserwować, że otrzymywane są dwa „rodzaje” zdarzeń – atrybut symbol jest równy ORCL albo BEA. 7. partycjonowanie (klauzula PARTITION BY) – wykonanie punkt 7 powyżej, umożliwia zastosowanie ciekawej funkcjonalności partycjonowania zdarzeń. Dzięki temu możliwe jest dodatkowe „podzielenie” okna na „pod-okna” dla unikalnych wartości określonego atrybutu, a następnie np. wyliczanie funkcji statystycznych (np. średniej) dla tych „pod-okien”. Przykładowe zapytanie korzystające z tej funkcjonalności: INSERT INTO NewHelloWorldEvent SELECT symbol, price, volume, AVG(volume) as metric FROM HelloWorldEvent RETAIN 2 EVENTS PARTITION BY symbol GROUP BY symbol Proszę zauważyć, że wartość średnia będzie wyliczana dla każdych dwóch zdarzeń, które mają tą samą wartość atrybutu symbol. Ponieważ w używanym tutaj przykładzie atrybut symbol ma tylko 2 wartości (ORCL lub BEA), to średnia wartość obrotów (volume) będzie wyliczona oddzielnie dla 2 zdarzeń o symbolu ORCL i 2 zdarzeń BEA (2 zdarzeń, bo takie jest okno: RETAIN 2 EVENTS). 8. parametryzowane zapytania EPL – możliwe jest określenie jednego lub więcej parametrów dla zapytania EPL. W ten sposób możliwe jest zdefiniowanie wielu podobnych zapytań, zamiast konieczności utrzymywania wielu kopii zapytania. W zapytaniu parametr określa się poprzez użycie „?”, np. tak, jak w poniższej regule (zakładając wcześniejsze wykonanie punktu 7 powyżej): INSERT INTO NewHelloWorldEvent SELECT symbol, price, volume, AVG(volume) as metric FROM HelloWorldEvent RETAIN 2 EVENTS PARTITION BY symbol WHERE price > ? GROUP BY symbol Następnie, w tym samym pliku konfiguracyjnym (\wlevs\config.xml) konieczne jest zdefiniowanie „powiązań” (bindings), łączących parametr w danym zapytaniu (to samo id), z konkretną wartością, np.: <params id="more_than_50">50

52

Możliwe jest zdefiniowanie wielu powiązań. 9. własne beany w sieci EPN – istnieje możliwość użycia własnego kodu Java (bean’ów) jako komponentów w sieci EPN. Własny bean może być zarówno źródłem (source) zdarzeń, jak i odbiorcą (listener). Taki bean pozwala na wpięcie własnej logiki przetwarzania zdarzeń do aplikacji (np. własnej implementacji procesora zdarzeń). Istnieją dwie możliwości – skorzystanie z tzw. Event Beans lub zwykłych bean’ów Spring. Event Beans mogą korzystać z funkcjonalności podsystemu monitorowania w Oracle CEP, nagrywania/odtwarzania zdarzeń, itp. Poniżej został opisany sposób tworzenia prostego własnego event bean’a i. własny bean będzie przetwarzał zdarzenia (tj. zarówno je odbierał, jak i po odpowiednim przetworzeniu generował). Logika własnego bean będzie polegać na multiplikowaniu atrybutu price w zdarzeniu przez konfigurowalną wartość (konfiguracja będzie odbywać się z wykorzystaniem techniki Dependency Injection oraz Spring Framework). ii. tworzenie implementacji klasy (zwykle zaczyna się od interfejsu, ale ten przykład będzie zaczynał od implementacji, z której zostanie wyekstraktowany interfejs). W Eclipse tworzymy nową klasę (New -> Class): • package: com.bea.wlevs.custombean • nazwa: MyBeanImpl iii. w tej klasie dodajemy atrybut i tworzymy dla niego getter/setter: private double multiplier; iv. w klasie MyBeanImpl dodajemy metodę o następującej sygnaturze: public void multiply(List listOfEvents) throws EventRejectedException Metoda ta będzie uruchamiana za każdym razem, gdy pojawi się zdarzenie, na które ten bean jest zasubskrybowany (jest to odpowiednik metody onEvent z interfejsu EventSink, z tym, że tutaj demonstrowana jest możliwość podłączenia dowolej klasy Java, niekoniecznie implementującej ten interfejs). v. za pomocą opcji Refactor -> Extract Interface w Eclipse, tworzymy interfejs MyBean, zawierający jedną metodę – multiply. vi. Ponieważ tworzony tu własny bean będzie także źródłem zdarzeń, to musi implementować interfejs EventSource i jego metodę setEventSender (dzięki tej metodzie, kontener CEP wstrzeli za pomocą techniki Dependency Injection obiekt, dzięki któremu będzie możliwe wysyłanie zdarzeń do kolejnego elementu w sieci EPN). Należy zatem dodać atrybut: private EventSender eventSender; a metoda setEventSender powinna wyglądać tak: public void setEventSender(EventSender eventSender) { this.eventSender = eventSender; }

53

vii. Poniżej znajduje się implementacja metody multiply, demonstrująca w jaki sposób przetwarzać zdarzenia przychodzące, modyfikować je i wysyłać je do pozostałych komponentów aplikacji: @SuppressWarnings("unchecked") public void multiply(List listOfEvents) throws EventRejectedException { List newList = new ArrayList(); for(Object event : listOfEvents) { if( event instanceof NewHelloWorldEvent) { NewHelloWorldEvent e = (NewHelloWorldEvent) event; e.setPrice(e.getPrice() * this.multiplier); newList.add(e); } } this.eventSender.sendEvent(newList, null); }

viii. Pozostaje jeszcze zadeklarować nowy bean oraz stosownie zmodyfikować sieć EPN. W poniższym przykładzie zmodyfikowana strumień helloWorldOutstreamwychodzący z procesora HelloWorldProcessor oraz utworzono nowy strumień (helloWorldOutstreamFinal). W efekcie zdarzenia wychodzące z procesora są przekazywane do własnego beana (MyBean), a następnie – po multiplikacji atrybutu price zdarzenia przez wartość określoną w konfiguracji (multiplier) – zdarzenia są przekazywane do bean’a HelloWorldBean, który wyświetla je na konsoli. <wlevs:event-bean id="myBean" class="com.bea.wlevs.custombean.MyBeanImpl" onevent-method="multiply"> <wlevs:instance-property name="multiplier" value="5.0" /> <wlevs:stream id="helloworldOutstream" advertise="true"> <wlevs:listener ref="myBean"/> <wlevs:source ref="helloworldProcessor"/> <wlevs:stream id="helloworldOutstreamFinal" advertise="true"> <wlevs:listener ref="helloWorldBean"/> <wlevs:source ref="myBean"/>

ix. Należy się jeszcze upewnić, że typ zdarzeń NewHelloWorldEvent został zarejestrowany w repozytorium typów zdarzeń: 54

<wlevs:event-type type-name="NewHelloWorldEvent"> <wlevs:class> com.bea.wlevs.event.example.helloworld.NewHelloWorldEvent

10. Własne beany w EPN mogą być także bean’ami Spring: i. opcjonalne, ale rekomendowane jest doinstalowanie do Eclipse wtyczek Spring IDE (http://springide.com). Dzięki temu możliwe będzie łatwiejsze tworzenie bean’ów Spring, w tym będzie wsparcie dla refaktoring’u i autouzupełniania konfguracji. ii. podobnie jak wcześniej należy utworzyć nową klasę oraz interfejs. Poniżej znajduje się przykładowy kod obu: public interface MyBeanSpring { public abstract void setEventSender(EventSender eventSender); @SuppressWarnings("unchecked") public abstract void onEvent(List listOfEvents) throws EventRejectedException; } public class MyBeanSpringImpl implements EventSource, EventSink, MyBeanSpring { private double multiplier; private EventSender eventSender; public void setEventSender(EventSender eventSender) { this.eventSender = eventSender; } public double getMultiplier() { return multiplier; } public void setMultiplier(double multiplier) { this.multiplier = multiplier; } @SuppressWarnings("unchecked") public void onEvent(List listOfEvents) EventRejectedException { List newList = new

throws

ArrayList(); for(Object event : listOfEvents) { if( event instanceof NewHelloWorldEvent) { NewHelloWorldEvent e = (NewHelloWorldEvent) event; e.setPrice(e.getPrice() * this.multiplier); newList.add(e); } } this.eventSender.sendEvent(newList, null);

55

} }

iii. Następnie, w folderze META-INF\spring należy utworzyć nową konfigurację Spring - definicje bean’ów (używając Spring IDE można to wykonać z menu New -> Other -> Spring Bean Definition). Jest to plik XML zawierający standardowe definicje bean’ów. Na przykład, tworząc plik myBeans.xml zawierający następującą treść: <property name="multiplier" value="10.0" />

iv. Należy także stosownie uaktualnić konfigurację sieci EPN, np. <wlevs:stream id="helloworldOutstream" advertise="true"> <wlevs:listener ref="myBeanSpring"/> <wlevs:source ref="helloworldProcessor"/> <wlevs:stream id="helloworldOutstreamFinal" advertise="true"> <wlevs:listener ref="helloWorldBean"/> <wlevs:source ref="myBeanSpring"/>

11. dynamiczna modyfikacja reguł – dotychczas modyfikując aplikację (np. zmieniając reguły) zmiany były publikowane poprzez re-instalację aplikacji (re-deployment), opcją Publish. Wiele z parametrów aplikacji zdarzeniowej w Oracle CEP może być jednak modyfikowanych dynamicznie, bez potrzeby re-deploymentu (a więc zatrzymywania aplikacji). W Oracle CEP jest dostępne narzędzie wlevs.Admin, które może być uruchomione np. z linii komend. Aby skorzystać z tej możliwości należy i. otworzyć okno linii komend (shell) ii. wpisać polecenie: java -jar c:\OCEP103\ocep_10.3\bin\wlevsadmin.jar -url service:jmx:rmi:///jndi/rmi://localhost:9004/jmxrmi -username wlevs -password wlevs HELP iii. można ułatwić sobie nieco zadanie i utworzyć skrypt systemu operacyjnego, w którym zawarta będzie większość typowych parametrów tego polecenia. Np. w wybranym folderze utworzyć plik o rozszerzeniu .cmd (np. wlevsAdmin.cmd w 56

folderze BEA_HOME\user_projects\scripts). Zawartość tego pliku powinna być następująca: java -jar c:\OCEP103\ocep_10.3\bin\wlevsadmin.jar -url service:jmx:rmi:///jndi/rmi://localhost:9004/jmxrmi -username wlevs -password wlevs %1 %2 %3 %4 %5 %6 %7 %8 %9 iv. należy sprawdzić poprawność działania tego skryptu, np. otwierając shell, przechodząc do folderu zawierającego skrypt i wykonując polecenie: wlevsAdmin HELP v. wyświetlanie określonej reguły EPL odbywa się poprzez: wlevsAdmin GETRULE –application ploug01 –processor helloworldProcessor -rule helloworldRule vi. aby zapisać aktualne reguły w lokalnym pliku (tu: w folderze c:\cep-rules, pod nazwą helloworld.txt), należy wykonać wlevsAdmin DOWNLOAD –application ploug01 –processor helloworldProcessor -file c:\cep-rules\helloworld.txt vii. taki plik można zmodyfikować przy użyciu dowolnego edytora tekstu (np. Notepad), a następnie „wgrać” (upload) na serwer: wlevsAdmin UPLOAD –application ploug01 –processor helloworldProcessor -sourceURL file:///c:/cep-rules/helloworld.txt Proszę zwrócić uwagę na znaki slash ‘/’ w ścieżce (URL). 12. wbudowane adaptery do JMS i HTTP Pub-Sub – Oracle CEP posiada wbudowane dwa adaptery, pozwalające odbierać i wysyłać komunikaty, odpowiednio: z/do systemu kolejkowego (JMS), z/do systemu posługującego się protokołem Bayeoux (mechanizm publishsubscribe z wykorzystaniem protokołu HTTP). Więcej informacji w dokumentacji produktu: i. JMS adapter: http://download.oracle.com/docs/cd/E13157_01/wlevs/docs30/ create_apps/jms.html ii. HTTP PubSub adapter: http://download.oracle.com/docs/cd/E13157_01/wlevs/docs30/ create_apps/pubsub.html 13. wbudowany generator zdarzeń - Oracle CEP posiada wbudowany generator zdarzeń, odczytujący wartości atrybutów zdarzeń z pliku CSV. Może to być przydatne do testowania aplikacji. Więcej informacji w dokumentacji produktu: http://download.oracle.com/docs/cd/E13157_01/wlevs/docs30/create_a pps/loadgen.html

57

14. nagrywanie / odtwarzanie zdarzeń – istnieje możliwość skonfigurowania komponentów aplikacji Oracle CEP, tak, aby zdarzenia wychodzące z komponentu (np. adaptera, czy procesora) były zapisywane na trwałe (domyślnie w bazie danych). Podobnie, można skonfigurować komponenty (np. strumień) tak, aby na ich wyjściu zostały odegrane (playback) wcześniej nagrane zdarzenia. Więcej informacji nt. tej funkcjonalności znajduje się w dokumentacji produktu: http://download.oracle.com/docs/cd/E13157_01/wlevs/docs30/create_a pps/store.html 15. visualizer – jest formą graficznej konsoli administracyjnej, pozwalającej na admonistrowanie i konfigurację domeny, serwerów, aplikacji i poszczególnych komponentów. Konsola ta jest dostępna pod adresem: http://hostname:port/wlevs (np. http://localhost:9002/wlevs). Więcej informacji: http://download.oracle.com/docs/cd/E13157_01/wlevs/docs30/visualiz er_help/using.html 16. klastrowanie – Oracle CEP zawiera wsparcie dla klastrowania, dzięki czemu możliwe jest zbudowanie wysokodostępnego rozwiązania klasy CEP. Więcej informacji: http://download.oracle.com/docs/cd/E13157_01/wlevs/docs30/config_ server/cluster.html 17. cache – Oracle CEP zawiera wbudowany rozproszony cache (Oracle Coherence), a także może korzystać z zewnętrznych systemów cache. Więcej informacji: http://download.oracle.com/docs/cd/E13157_01/wlevs/docs30/create_a pps/cache.html

58

N. Kontakt do prowadzącego Waldemar Kot Principal Sales Consultant, Eastern Europe Oracle Polska Sienna 75, 00-833 Warszawa Tel. Kom.: +48 660 78 55 78 Tel. Biurowy: +48 22 6908 664 Email: [email protected]

Zapraszam 

59