Dariusz [LocK] Łuksza » xmpp-pubsub

XMPP-PubSub w Java (cz. 2)

Dariusz Łuksza — Mon, 10 Nov 2008 11:47:52 +0000

W poprzednim wpisie, pokazałem jak wystawić pojedynczy węzeł (node), dziś zrobię/zrobimy trochę więcej, a mianowicie opublikujemy „wiadomość”, a przede wszystkim odbierzemy zdarzenie o utworzeniu wiadomości. Przecież o tą zaletę XMPP-PubSub nam (a przynajmniej mi ) najbardziej chodzi … o jego zdarzeniowy charakter ;> … a więc do roboby

Żeby to co piszę było bardziej uniwersalne, celem wprowadzenia warte opisania są właściwości zdarzeniowe obu bibliotek do obsługi XMPP (mam tu na myśli smack (do obsługi samego XMPP) i su-smack (do obsługi XMPP-PubSub)). Pewnie bardziej dociekliwy czytelnik zauważył w poprzedniej części dodanie PacketListener‘a do obiektu połączenia, dla mniej dociekliwych i uważnych poniżej znajduje się ten kawałek kodu:

con.addPacketListener(new PacketListener() {
    public void processPacket(Packet pkt) {
        System.out.println(pkt.toXML());
    }
}, null);

Co ja tutaj takiego zrobiłem ? … W ten sposób rozwiałem problem z debug’owaniem pakietów jakie wracały z serwera, gwoli ścisłości metoda addPacketListener przyjmuje 2 parametry, pierwszy z nich jest to wspominany w nazwie PacketListener (interfejs z jedną metodą void processPacket(Packet pkt)), oraz obiekt PacketFilter. Dzięki takiemu rozwiązaniu programista jest odciążony z obowiązku własnoręcznego oprogramowywania otrzymywanych pakietów. Mały przykład, załóżmy że interesują nas tylko wiadomości od jednego użytkownika … nic prostszego:

PacketFilter filter = new AndFilter(new PacketTypeFilter(Message.class),
            new FromContainsFilter("my-love@jabber.swh"));
conn.addPacketFilter(new PacketFilter() {
    public void processPacket(Packet pkt) {
        System.out.println("My love is writing to me ;).")
    }
}, filter );

W ten oto prosty sposób mamy rozwiązany powyższy problem .

Jeżeli chodzi natomiast nasłuchiwanie na pakiety PubSub sprawa jest odrobinę bardziej zakręcona … biblioteka su-smack posiada jedna pomocniczą klasę XMPPUtils która jest bardzo ciekawa ;> posiada ona tylko 5 metod (z czego 2 są dodatkowo przeciążone), na chwilę obecną będą nas interesować tylko 2 obecne tam publiczne statyczne metody: createEventPacketListener(PubSubEventListener listener) oraz createPubSubFilter(). Pierwsza z nich zwraca obiekt PacketListener dla przekaznego w parametrze obiektu PubSubEventListener, a co robi druga jest bardzo łatwo się domyślić .


Dodatkowo nasz program kliencki będzie się subskrybował do węzła ... kod subskrypcji jest bardzo prosty i nie wymaga opisu IMHO. Poniżej znajduje się kompletny kod klienta:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
/*
 *     Published on GNU GPLv2
 */
package org.luksza.xmpp.pubsub;
 
import org.jivesoftware.smack.ConnectionConfiguration;
import org.jivesoftware.smack.PacketCollector;
import org.jivesoftware.smack.PacketListener;
import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.filter.PacketIDFilter;
import org.jivesoftware.smack.packet.Packet;
import org.jivesoftware.smack.packet.IQ.Type;
 
import se.su.it.smack.pubsub.PubSub;
import se.su.it.smack.pubsub.PubSubEventListener;
import se.su.it.smack.pubsub.elements.DeleteElement;
import se.su.it.smack.pubsub.elements.ItemElement;
import se.su.it.smack.pubsub.elements.PurgeElement;
import se.su.it.smack.pubsub.elements.RetractElement;
import se.su.it.smack.pubsub.elements.SubscribeElement;
import se.su.it.smack.utils.XMPPUtils;
 
/**
 * @author Dariusz [LocK] Łuksza
 */
public class SubscribeToNode {
 
    private static final String login = "pubsub-test";
    private static final String pass = "pubsub-test";
    private static final String pubSubServerUrl = "pubsub.server";
 
    public static void main(String[] args) {
        final XMPPConnection con = new XMPPConnection(new ConnectionConfiguration("server"));
        try {
            System.out.print("Connecting ...");
            con.connect();
            if (con.isConnected()) {
                System.out.print(" DONE.\nLogging ...");
                con.login(login, pass);
                if (con.isAuthenticated()) {
                    System.out.print(" DONE.\nSubscribing to node ...");
                    final PubSub pubSubSubscribe = new PubSub();
                    pubSubSubscribe.setTo(pubSubServerUrl);
                    pubSubSubscribe.setType(Type.SET);
                    pubSubSubscribe.setFrom(con.getUser());
                    final SubscribeElement subscribe = new SubscribeElement("/home/server/blee");
                    subscribe.setJid(con.getUser());
                    pubSubSubscribe.addChild(subscribe);
                    XMPPUtils.sendAndWait(con, pubSubSubscribe); // subskrybcja jest zawsze akceptowana.
                    System.out.println(" DONE.");
 
                    PacketListener pubsubPacketListner = XMPPUtils.createEventPacketListener(
                                new MyPubSusEventListener(con)
                            );
                    con.addPacketListener(pubsubPacketListner, XMPPUtils.createPubSubFilter());
 
                    XMPPUtils.sendAndWait(con, pubSubSubscribe);
 
                    while (true) {
                        Thread.sleep(10);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            con.disconnect();
        }
    }
 
    public static class MyPubSusEventListener implements PubSubEventListener {
 
        private final XMPPConnection _con;
 
        public MyPubSusEventListener(final XMPPConnection con) {
            _con = con;
        }
 
        public void onDelete(final DeleteElement element) throws Exception {
            System.out.println("Deleted element: " + element.toXML());
        }
 
        // w parametrze przekazywana jest tylko nazwa utworzonego elemnu
        public void onPublish(final ItemElement elemnt) throws Exception {
            System.out.println("\n\tPublished element:\n" + elemnt.toXML());
            // zeby odebrac dane trzeba opakowac otrzymany element
            // w "caly pakiet"
            final PubSub getItem = new PubSub();
            getItem.setType(Type.GET);
            getItem.setTo(pubSubServerUrl);
            getItem.setFrom(_con.getUser());
            getItem.addChild(elemnt);			
 
            // zeby odebrac dane trzeba poczekac na pakiet z id
            // takim samym jak wyslane
            final PacketCollector collector = _con.createPacketCollector(
                    new PacketIDFilter(getItem.getPacketID())
                );
            _con.sendPacket(getItem); // wysylanie
            final Packet result = collector.nextResult(); // oczekiwanie na wynik
 
            System.out.println("\n\tRetrive data:" + result.toXML());
        }
 
        public void onPurge(final PurgeElement elemnt) throws Exception {
            System.out.println("Purged element: " + elemnt.toXML());
        }
 
        public void onRetract(final RetractElement elemnt) throws Exception {
            System.out.println("Retracted element: " + elemnt.toXML());
        }
    }
}

Kod "serwera" (tj. aplikacji publikującej dane) jest bardzo prosty, i sprowadza się do użycia odpowiednich klas i ich wysłania ...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/*
 * 	Published on GNU GPLv2
 */
package org.luksza.xmpp.pubsub;
 
import org.jivesoftware.smack.PacketListener;
import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.packet.Packet;
import org.jivesoftware.smack.packet.IQ.Type;
 
import se.su.it.smack.pubsub.PubSub;
import se.su.it.smack.pubsub.elements.ItemElement;
import se.su.it.smack.pubsub.elements.PublishElement;
import se.su.it.smack.utils.XMPPUtils;
 
/**
 * @author Dariusz [LocK] Łuksza
 */
public class PubSubCreateNode {
 
    public static void main(final String[] argv) throws Exception {
        final String login = "blee";
        final String serverHost = "server";
        final XMPPConnection con = new XMPPConnection(serverHost);
        con.connect();
        try {
            con.login(login, "pass");
            if (con.isAuthenticated()) {
                final PubSub pubSub = new PubSub();
                pubSub.setType(Type.SET);
                pubSub.setFrom(con.getUser());
                pubSub.setTo("pubsub."  + serverHost);
 
                final PublishElement publish = new PublishElement("/home/" + serverHost + "/" + login);
                final ItemElement item = new ItemElement("Test Item");
 
                item.setContent("Test TEST test");
                publish.addChild(item);
                pubSub.addChild(publish);
 
                XMPPUtils.sendAndWait(con, pubSub);
            } else {
                System.out.println("Not authenticated!");
                return;
            }
        } finally {
            con.disconnect();
        }
    }
 
}

Jak to działa ? Najpierw odpalamy "klienta" który subskrybuje się do węzła i nasłuchuje (w nie skończoność) na nowe dane. Potem odpalamy kod publikujący dane, aplikacja się spokojnie wykona, a w kliencie dostaniemy informacje o tym, że została opublikowana nowa wiadomość jak i od razu ją odbieramy  
Ciekawe linki:

oczywiście XEP-0060
ciekawy artykuł, nie przeczytałem całego   ale zamieszczone tam kody  pomogły mi zrozumieć parę rzeczy



XMPP-PubSub w Java i nie tylko (cz. 1)
Dariusz Łuksza — Sat, 01 Nov 2008 17:07:48 +0000
W ramach eksternistycznego zaliczenia przedmiotu Systemy internetowe, muszę wykonać aplikację w architekturze SOA z wykorzystaniem
XMPP-PubSub (XEP-0060). Jako, że temat jest ciekawy i (IMHO) przyszłościowy postaram się go przybliżyć w paru notkach.
Czego można się po tych notkach spodziewać ? Przede wszystkim działających (w chwili publikacji  ) fragmentów kodu, opisów problemów jakie napotkałem podczas realizacji projektu … oraz ich rozwiązań. Wszystko oczywiście, jak to u mnie bywa, w mniej lub bardziej chaotycznej formie ;>

Na początek może trochę teorii i historii (oczywiście z mojego punktu widzenia).
Co to jest XMPP ? Cóż, część osób będzie kojarzyć ten termin z Jabber’em … i słusznie, sam Jabber jest przodkiem XMPP , jako że całość bazuje na XML’u jest to potężne „narzędzie” mogące służyć nie tylko do komunikacji w internecie, ale też do wielu innych celów.
Co to jest PubSub ? Właściwie to Publish-Subscribe; jest to jedna z wielu ” usług” jakie udostępnia XMPP, umożliwia ona „wystawianie” wiadomości. Dzięki wykorzystaniu Observer patter eliminuje zbędny ruch sieciowy (klient nie pyta serwera co 5 min „masz już coś dla mnie?” … „a może teraz masz ?”), umożliwa praktycznie natychmiastowe informowanie klientów o zmianach/nowościach.
Z czym to się je ? Właściwie to ze wszystkim i niczym … tj. na pewno potrzebny jest serwer Jabbera z zaimplementowaną obsługa pub-sub (może to być np. ejabberd2 czy jabberd2, ja będę używał tego pierwszego z racji że „posiadam” go od paru lat  ) i to by był na tyle … no ale w sumie to jeszcze można by z tego zrobić jakis użytek, dosłownie „jakiś”. Tak więc będą nam do tego potrzebne jakieś biblioteki … z takowymi nie ma problemu, chwila googlania zaprowadziła mnie do (wspominanego wyżej) smack’a i su-smack’a. Ok, całkiem fajnie, mi się to podoba … tylko po co mi do tego jeszcze jakiś dodatkowy serwer i to jeszcze jabbera ? Jest on po to, żeby ułatwić sobie życie, robi on za taki „programowy switch”, z wykorzystaniem smack’a można na takim serwerze wystawić node’a z danymi i odpowiednią konfiguracją … i o nim poprostu zapomnieć, dalej nasza zewnętrzna aplikacja (czyli OpenSource’owy, całkowicie darmowy soft) zrobi za nas wszystko, tj. roześle informacje do tych klientów którzy się zapisali na listę chętnych do odebrania informacji (tutaj jest właśnie nasz Observer pattern). Architektura jest bardzo prosta, klient podłącza się do serwera i zapisuje się (lub jak kto woli subscribe’uje), na zdarzenia (eventy), z drugiej strony łączy się inny klient czy serwer i wystawia dane (tu się znowu powtórzę) reszte robi za nas Observer pattern i serwer jabbera. … Ok wszystko fajnie, no ale ja nie chce czy też nie mogę/nie umiem/nie mam gdzie (nie potrzebne skreślić) postawić taki serwer. Nie musisz ;P możesz użyć jakiegoś publicznego, wystarczy rejestracja (a czasem nawet i to nie jest wymagane).
Smack i su-smack. Obie biblioteki są open-source’owe, pierwszy na licencji Apache, a drugi na Stockholm university BSD License. Więc nie będą sprawiać żadnych problemów ;>. Obie są w całości napisane w Java’ie, trafiłem na nie po chwili google’ania  
OK, koniec tego długiego i nudnego wstępu, czas zabrać się za to co tygryski lubią najbardziej ;> … czyli konfiguracje … żartuje, oczywiście najlepszą częścią będzie kodowanie, ale chcąc być trendy i wogole super … zwłaszcza, że oba projekty na to pozwalają … chciał bym przedstawić konfigurację maven‘a. W pliku pom.xml w sekcji repositories dodajemy repo (lub jak kto woli można to zrobić w $M2_HOME/setttings.xml, ale lepiej nie uzależniać projektu od globalnej konfiguracji  )


it.su.se

su-smack

http://maven.it.su.se/it.su.se/maven2


natomiast do sekcji dependenties dodajemy:


su-smack

su-smack

1.4-SNAPSHOT


Teraz właściwa część notki … kod ;>. Najpierw założenia, chcemy się podlaczyć do serwera jabber’a, zalogować się i stworzyć w węzeł, dodatkowo dodam PacketListener żeby widzieć jak wygladą komunikacja pomiędzy serwerem jabber’a, a kodem. Kod nie jest zaawansowany więc nie sądze żeby wymagał opisu.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
/*
 * 	Published on GNU GPLv2
 */
package org.luksza.xmpp.pubsub;
 
import org.jivesoftware.smack.PacketListener;
import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.packet.Packet;
import org.jivesoftware.smack.packet.IQ.Type;
import se.su.it.smack.pubsub.PubSub;
import se.su.it.smack.pubsub.elements.ConfigureElement;
import se.su.it.smack.pubsub.elements.CreateElement;
 
/**
* @author Dariusz [LocK] Łuksza
*/
public class PubSubCreateNode {
 
    public static void main(final String[] argv) throws Exception {
        final String login = "login";
        final XMPPConnection con = new XMPPConnection("jabber.host");
        con.connect();
        con.addPacketListener(new PacketListener() {
            public void processPacket(Packet pkt) {
                System.out.println(pkt.toXML());
            }
        }, null);
        try {
            con.login(login, "pass");
            if (con.isAuthenticated()) {
                final PubSub pubSub = new PubSub();
                pubSub.setType(Type.SET);
                pubSub.setTo("pubsub.jabber.host");
                pubSub.setFrom(con.getUser());
                pubSub.addChild(new CreateElement("/home/jabber.host/" + login));
                pubSub.addChild(new ConfigureElement());
                con.sendPacket(pubSub);
                Thread.sleep(5000);
            } else {
                System.out.println("Not authenticated!");
                return;
            }
        } finally {
            con.disconnect();
        }
    }
}

Po uruchowmieniu, używając jakiegoś klienta jabber’a (tkabber’a czy np. psi) możemy sprawdzić czy węzeł został utworzony. Należy pamiętać o tym że nie można tworzyć wiely węzłów naraz.I to by było chyba na tyle