====== LAB: Integracja z HTTP/WWW ======
Celem laboratorium jest ukazanie podstawowych metod integracji języka Prolog z protokołem HTTP, używania gniazd TCP oraz zademonstrowanie wielowątkowości w SWI-Prolog.
===== -. Wątki =====
Wielowątkowość w SWI-Prolog oparta jest na standardzie POSIX.
Dokumentacja: [[http://www.swi-prolog.org/pldoc/doc_for?object=section(1%2c%20%278%27%2c%20swi(%27%2fdoc%2fManual%2fthreads.html%27))|Multi-threaded applications]]
==== Tworzenie wątków ====
Tworzenie oddzielnego wątku odbywa się przy użyciu predykatu thread_create/3:
thread_create(:Goal, -Id, +Options)
Predykat //thread_self/1// zwraca identyfikator wątku, w którym został wywołany.
**Ćwiczenie:**
Proszę wkleić poniższy kod do pliku i wczytać go w SWI-Prolog:
start :-
thread_create(write_ID(10),ID1,[]),
write('Thread with ID: '), write(ID1), writeln(' has been started!'),
thread_create(write_ID(10),ID2,[]),
write('Thread with ID: '), write(ID2), writeln(' has been started!').
write_ID(0).
write_ID(Times) :-
thread_self(ID),
write(ID),
NewTimes is Times - 1,
write_ID(NewTimes).
Proszę uruchomić program predykatem //start/0// kilkakrotnie i zaobserwować działanie.
==== Synchronizacja wątków ====
SWI-Prolog implementuje semafor, który można wykorzystać do kontroli sekcji krytycznej - mutex (MUTual EXclusive device). Proszę zapoznać się z predykatami: [[http://www.swi-prolog.org/pldoc/man?predicate=mutex_lock%2f1|mutex_lock/1]] i [[http://www.swi-prolog.org/pldoc/man?predicate=mutex_unlock%2f1|mutex_unlock/1]].
**Ćwiczenie**
Kod programu z poprzedniego ćwiczenia proszę zmodyfikować tak, aby zaobserwować niepożądany efekt korzystania z jednego zasobu przez więcej niż jeden wątek jednocześnie. Druga klauzula predykatu //write_ID/1// mogłaby wyglądać np. tak:
write_ID(Times) :-
thread_self(ID),
write(ID), write(': I am running! '),
NewTimes is Times - 1,
write_ID(NewTimes).
Proszę przetestować, czy zamierzony efekt zachodzi, a następnie tak zmodyfikować program, aby komunikaty jednego wątku (np. //2: I am running!//) nie przeplatały się z komunikatami drugiego.
==== Komunikacja między wątkami ====
Każdy wątek ma przypisaną kolejkę wiadomości, z której może odczytywać wiadomości wysyłane przez inne wątki w postaci termu.
//thread_send_message(+ThreadId, +Term)// - wysyła wiadomość w postaci termu do kolejki wiadomości wskazanego wątku.
//thread_get_message(?Term)// - czeka na wiadomość w kolejce, która będzie mogła być zunifikowana z termem //Term//.
//threads/0// - podaje informacje o pracujących/zakończonych wątkach i status każdego z nich.
**Ćwiczenie**
Proszę wkleić poniższy kod do pliku i wczytać go w SWI-Prolog:
start :-
thread_create(do_nothing,ID1,[]),
write('Thread with ID: '), write(ID1), writeln(' has been started!'),
thread_create(do_nothing,ID2,[]),
write('Thread with ID: '), write(ID2), writeln(' has been started!').
do_nothing :-
thread_self(ID),
thread_get_message(say(A)),
write('Thread '), write(ID), write(' says: '), writeln(A).
Po użyciu predykatu //start/0// dwa wątki pracują i czekają na wiadomość w postaci termu //say/1//.
Proszę użyć predykatu //threads/0// i zauważyć, że główny wątek (ten, w którym wpisuje się polecenia w konsoli) także jest wylistowany i zachowuje się jak inne wątki (można mu wysłać wiadomość, można go synchronizować z innymi, itp.).
Proszę wpisać w konsoli: thread_send_message(ID,say('Something stupid!')), gdzie ID to identyfikator jednego z pracujących wątków. Po ponownym użyciu predykatu //threads/0// proszę zauważyć, że jeden z wątków zmienił status. Został zakończony sukcesem (//true//). Proszę wysłać wiadomość także do drugiego oczekującego wątku.
==== Problem pięciu filozofów ====
Proszę zapoznać się z [[http://pl.wikipedia.org/wiki/Problem_ucztuj%C4%85cych_filozof%C3%B3w|problemem pięciu filozofów w Wikipedii]]. To klasyczny problem, którego rozwiązanie korzysta z wielowątkowości i synchronizacji wątków. Proszę wczytać plik {{5_philosophers.pl}}, zapoznać się z nim i uruchomić predykatem //start/0//. W początkowej części programu znajdują się ustawienia. Proszę je zmodyfikować wg własnego uznania i przetestować poprawność działania programu.
===== -. Gniazda TCP =====
Biblioteka //socket// udostępnia w SWI-Prolog obsługę gniazd TCP po stronie klienta i serwera.
Istotne predykaty:
* //tcp_socket(-SocketId)// inicjalizuje gniazdo i unifikuje jego identyfikator ze zmienną logiczna //SocketId//,
* //tcp_connect(+Socket,+Host:+Port)// dokonuje połączenia z hostem na wskazanym porcie przy użyciu uprzednio zainicjowanego gniazda,
* //tcp_open_socket(+SocketId,-InStream,-OutStream)// otwiera dwa strumienie (wejścia i wyjścia) SWI-Prolog dla gniazda,
* //tcp_accept(+Socket,-Slave,-Peer)// działa po stronie serwera, oczekuje na połączenie ze strony klienta, tworzy nowe gniazdo dla klienta o identyfikatorze //Slave//, zmienna logiczna //Peer// jest unifikowana z adresem IP klienta.
* //tcp_close_socket(+SocketId)// zamyka gniazdo. Ten sam efekt można uzyskać zamykając strumienie gniazda predykatem //close/1//.
**__UWAGA!__ W poniższych ćwiczeniach z użyciem gniazd TCP proszę używać portów z zakresu 33700-33999.**
==== Klient i serwer ====
**W tym ćwiczeniu proszę zmienić numer portu na dowolny z zakresu 33700-33999, aby nie przeszkadzać kolegom.**
:- use_module(library(socket)).
create_client :-
tcp_socket(Socket),
tcp_connect(Socket,localhost:33888),
tcp_open_socket(Socket,Read,Write),
write(Write,'matka(kasia,robert).'),nl(Write),
close(Read),
close(Write).
create_server :-
tcp_socket(Socket),
tcp_bind(Socket,33888),
tcp_listen(Socket,5),
tcp_open_socket(Socket,_,_),
tcp_accept(Socket, Slave, _), % Akceptacja połaczenia ze strony klienta.
tcp_open_socket(Slave, In, Out),
read(In,Msg), % Odczyt wiadomości.
write(Msg),
close(In),
close(Out).
* Predykat //create_client/0// tworzy obsługę gniazda TCP po stronie klienta, wysyła do serwera komunikat w postaci termu, a następnie zamyka połączenie.
* Predykat //create_server/0// dzieli się na dwie części. Pierwsza tworzy gniazdo, a druga obsługuję przychodzące połączenie. Predykat //tcp_accept/3// oczekuje do momentu nawiązania połączenia przez klienta.
**Ćwiczenie:**
Proszę wczytać powyższy program, uruchomić serwer w osobnym wątku (//thread_create/3//) i nawiązać z nim połączenie.
Następnie proszę tak zmodyfikować predykat //create_server/0//, aby był w stanie obsłużyć więcej niż jedno połączenie (niekoniecznie symultanicznie, może być jedno po drugim) i przy każdym dopisywał przesłany term do bazy wiedzy (//assert/1//).
==== Komunikator ====
Program {{komunikator.pl|komunikator}} wykorzystuje gniazda TCP w celu stworzenia w Prologu prymitywnej wymiany wiadomości między użytkownikami. Proszę się z nim zapoznać Jest podzielony na część klienta i serwera. W rzeczywistości jest to rozbudowana wersja prostego programu z przykładu zamieszczonego wyżej. Dodana jest odpowiednia interpretacja komunikatów. Owe komunikaty są przesyłane w postaci termów, więc każdy musi być zakończony kropką.
**Ćwiczenie:**
Po zapoznaniu z programem proszę się porozumieć z kolegami wykonującymi to samo ćwiczenie. Niech jeden ze studentów uruchomi serwer komunikatora na ustalonym porcie przy użyciu predykatu //start_server/0//. Pozostali niech się z nim połączą przy użyciu predykatu //start_client/1//. Np. //start_client(ania)//. Proszę przetestować działanie komunikatora.
Przykładowa sesja po stronie klienta może wyglądać następująco:
1 ?- start_client(ania).
|: Server message: Hello! I am a communication server
Server message: Type commands:
|: who.
|: Users connected to the server:
- ania
- bartek
|: msg(bartek,"Cześć Bartek!").
|: Message from bartek: Cześć Aniu!
|: quit.
|: Connection closed by server.
===== -. HTTP =====
W SWI-Prolog do dyspozycji są dwie biblioteki integrujące z protokołem HTTP od strony klienta:
* [[http://www.swi-prolog.org/pldoc/doc_for?object=section(3%2c%20%272.1%27%2c%20swi(%27%2fdoc%2fpackages%2fhttp.html%27))|http/http_open]] - oparta jedynie na metodzie HTTP GET,
* [[http://www.swi-prolog.org/pldoc/doc_for?object=section(3%2c%20%272.2%27%2c%20swi(%27%2fdoc%2fpackages%2fhttp.html%27))|http/http_client]] - bardziej rozbudowana.
==== http_open - get ====
Biblioteka http_open jest prostsza, daje mniejsze możliwości, ale wystarczająca, jeśli ograniczamy się do ściągnięcia kodu html strony.
Predykat //http_open(+URL,-Stream,+Options)// otwiera strumień dla wskazanego adresu URL. Po skorzystaniu ze strumienia należy go zamknąć tak jak każdy inny strumień w prologu: //close(+Stream)//.
**Ćwiczenie:**
:- use_module(library(http/http_open)).
view_site :-
http_open('http://www.google.pl',In,[]),
copy_stream_data(In,user_output),
close(In).
==== http_open - head ====
Opcja //method(head)// predykatu //open/3// powoduje, że odczytywany jest tylko nagłówek strony. W połączeniu z opcją //header(+Name,-AtomValue)// można uzyskać konkretne pole nagłówka.
**Ćwiczenie**
:- use_module(library(http/http_open)).
view_date :-
http_open('http://www.google.pl',In,[method(head),header(date,Date)]),
copy_stream_data(In,user_output),
close(In),
writeln(Date).
Proszę odczytać także inne pola nagłowka, np. content_type (myślnik jest zastępowany przez podkreślenie).
==== http_client - GET ====
Predykat //http_get(+URL, -Reply, +Options)// unifikuje zmienna logiczną Reply z odpowiedzią serwera, uzyskaną przy użyciu metody GET.
**Ćwiczenie:**
:- use_module(library(http/http_client)).
view_site :-
http_get('http://www.google.pl',Reply,[]),
write(Reply).
==== Dla zainteresowanych ====
SWI-Prolog udostępnia także bibliotekę HTTP od strony serwera. Pełna dokumantacja znajduje się na stronie: [[http://www.swi-prolog.org/pldoc/package/http.html|SWI-Prolog HTTP support]].
====== Uwagi, komentarze, propozycje ======
Tu studenci mogą wpisywać swoje uwagi.
--- //[[gjn@agh.edu.pl|Grzegorz J. Nalepa]] 2009/05/06 09:13//