💇🏼 🧘🏾 🙋🏽 Ejabberd के लिए एक मॉड्यूल लिखना 🧑‍🤝‍🧑 🚧 🎅

यदि आपको ejabberd XMPP सर्वर से गैर-मानक कार्यक्षमता की आवश्यकता है, तो आप नहीं जानते कि इसे नियमित टूल का उपयोग करके इसे कैसे कॉन्फ़िगर किया जाए और आपको इसके लिए उपयुक्त मॉड्यूल नहीं मिला, आप इस मॉड्यूल को स्वयं लिख सकते हैं।

इसलिए मैंने फैसला किया कि जब अधिकारियों ने जैबर में बेकार की बकवास पर युद्ध की घोषणा की, जिसके लिए कुछ उपयोगकर्ताओं को दूसरों के साथ चैट करने से रोकना आवश्यक था, लेकिन तीसरे के साथ अनुमति देने के लिए। और हालांकि मुझे अभी भी एक अस्पष्ट संदेह है कि इसे एक्सेस सूचियों का उपयोग करके कॉन्फ़िगर किया जा सकता है, मैंने एक मॉड्यूल लिखने का फैसला किया जो मेरे लिए उपयोग करने के लिए सुविधाजनक होगा। यह मॉड्यूल कहानी के लिए एक उदाहरण के रूप में काम करेगा।

ट्रेनिंग

पहले आपको कम से कम थोड़ी प्रोग्रामिंग लैंग्वेज इरलांग सीखने की जरूरत है। मैंने आरएसडीएन पत्रिका के एक लेख के अनुवाद और आधिकारिक दस्तावेज का उपयोग किया ।
उसके बाद, आपको मॉड्यूल बनाने के लिए कंप्यूटर को तैयार करने की आवश्यकता है। स्थापित इरलैंग और इज़बर्ड के अलावा, हमें अपने मॉड्यूल से कुछ पुस्तकालयों को जोड़ने के लिए उनके स्रोत कोड की आवश्यकता होगी।

कार्रवाई में मॉड्यूल की जांच करने के लिए, आपको आवश्यकता होगी:

इसे संकलित करें।
```
$ erlc mod_restrictions.erl 
```
परिणामी बाइनरी को फ़ोल्डर में ईज़बर्ड में ले जाएं।
```
 $ mv mod_restrictions.beam /usr/lib/ejabberd/ebin/ 
```
नया (अपडेटेड) मॉड्यूल डाउनलोड करें। ऐसा करने के लिए, आप बस ejabberd को पुनः आरंभ कर सकते हैं:
```
 $ service ejabberd restart 
```
और आप मक्खी पर मॉड्यूल को अपडेट कर सकते हैं , उदाहरण के लिए, ईज़बर्ड एडमिन एरिया ( नोड्स -> आपका नोड -> अपडेट ) में

(Ubuntu 11.04 के लिए आदेश)

संकलक कुछ इस तरह लिख सकता है:

 ./mod_restrictions.erl:5: Warning: behaviour gen_mod undefined

यह डरावना नहीं है, सब कुछ काम करेगा। यदि कोई अन्य त्रुटियां और चेतावनी हैं, तो आपको उनसे निपटने की आवश्यकता है।

इज़बेर कॉन्फ़िगरेशन (फ़ाइल /etc/ejabberd/ejabberd.cfg) में एक मॉड्यूल कनेक्ट करने के लिए, मॉड्यूल की सूची में लाइन जोड़ें ( {modules,[ बाद:

 {mod_restrictions, []}

कंकाल

Ejabberd मॉड्यूल gen_mod इंटरफ़ेस को इनहेरिट करना होगा। इस व्यवहार के लिए दो कार्यों की आवश्यकता होती है: प्रारंभ / 2 और स्टॉप / 1 , जिसे क्रमशः कहा जाएगा, जब मॉड्यूल शुरू होता है और बंद हो जाता है। हम निम्न कोड को mod_restrictions.erl फ़ाइल में लिखते हैं:

 -module(mod_restrictions). -behavior(gen_mod). -export([start/2, stop/1]). start(_Host, _Opts) ->  ok. stop(_Host) ->  ok.

यहाँ हम हैं:

मॉड्यूल का नाम निर्दिष्ट करें (यह बिना .erl के फ़ाइल के नाम की तरह होना चाहिए)।
हमें gen_mod का व्यवहार विरासत में मिला है।
हम कहते हैं कि फ़ंक्शन शुरू (दो तर्कों के साथ) और स्टॉप (एक तर्क के साथ) मॉड्यूल के बाहर से सुलभ हैं।
हम एक फ़ंक्शन लिखते हैं। तर्क नामों में निचला स्थान एरलंग बताता है कि इन तर्कों का उपयोग नहीं किया गया है।
ठीक है लौटो

हम लॉग में लिखते हैं

लॉग में एक घटना रिकॉर्ड करने के लिए (उदाहरण के लिए, कि मॉड्यूल शुरू और बंद हो गया है), आप INFO_MSG मैक्रो का उपयोग कर सकते हैं:

 -module(mod_restrictions). -behavior(gen_mod). -include("ejabberd.hrl"). -export([start/2, stop/1]). start(Host, _Opts) ->  ?INFO_MSG("mod_restrictions   ~p", [Host]),  ok. stop(Host) ->  ?INFO_MSG("mod_restrictions   ~p", [Host]),  ok.

सबसे पहले, हम स्थूल परिभाषा INFO_MSG के साथ ejabberd.hrl फ़ाइल शामिल करते हैं। ध्यान दें कि आपको कनेक्ट की गई फ़ाइल के लिए पूर्ण या सापेक्ष पथ निर्दिष्ट करना होगा, विशेष रूप से यह एक ईज़बेर के स्रोत कोड में निहित है।
सर्वर लॉग्स में हमारा संदेश दिखाई देगा (मेरे पास यह /var/log/ejabberd/ejabberd.log है), और प्रत्येक ~ पी के बजाय सूची से एक तत्व होगा - दूसरा तर्क।

ईजबर्ड इवेंट हैंडलिंग

एज़बर्ड घटनाओं (घटनाओं) और हुक (हुक) के तंत्र का उपयोग करके मॉड्यूल को इसमें एकीकृत करने की अनुमति देता है।

 ejabberd_hooks:add(Hook, Host, Module, Function, Prioritet) ejabberd_hooks:remove(Hook, Host, Module, Function, Prioritet)

Ejabberd मॉड्यूल मॉड्यूल के फ़ंक्शन फ़ंक्शन को कॉल करेगा (उपयोग करें ? MODULE मैक्रो ताकि यह आपका मॉड्यूल है) हर बार होस्ट नोड पर एक हुक घटना होती है (यदि आप सभी नोड्स सुनना चाहते हैं तो वैश्विक उपयोग करें)। इस लिंक पर संभावित घटनाओं की एक सूची देखी जा सकती है। यदि एक घटना के लिए कई ग्राहक हैं, तो उन्हें बदले में निष्पादित किया जाता है, पहले एक उच्च प्राथमिकता के साथ।
हम filter_packet ईवेंट में रुचि रखते हैं, जो हर बार होता है जब कोई व्यक्ति किसी को कुछ भेजता है (उदाहरण के लिए, एक संदेश)।
अब मॉड्यूल इस तरह दिखता है:

 -module(mod_restrictions). -behavior(gen_mod). -include("ejabberd.hrl"). -export([start/2, stop/1, on_filter_packet/1]). start(_Host, _Opts) ->  ejabberd_hooks:add(filter_packet, global, ?MODULE, on_filter_packet, 50),  ok. stop(_Host) ->  ejabberd_hooks:delete(filter_packet, global, ?MODULE, on_filter_packet, 50),  ok. on_filter_packet(Packet) ->  Packet.

व्यवस्थापक पैनल में एक मॉड्यूल जोड़ना

उपयोगकर्ताओं और समूहों को प्रबंधित करने के लिए, मैं ejabberd वेब इंटरफ़ेस में एक मॉड्यूल जोड़ना चाहता हूं। इसके बारे में यहाँ और पढ़ें।

हम आवश्यक फाइलें और ऐड-रिमूव हुक जोड़ते हैं:

 -include("web/ejabberd_http.hrl"). -include("web/ejabberd_web_admin.hrl"). start(_Host, _Opts) ->  ...  ejabberd_hooks:add(webadmin_menu_main, ?MODULE, web_menu_host, 50),  ejabberd_hooks:add(webadmin_page_main, ?MODULE, web_page_host, 50),  ... stop(_Host) ->  ...  ejabberd_hooks:delete(webadmin_menu_main, ?MODULE, web_menu_host, 50),  ejabberd_hooks:delete(webadmin_page_main, ?MODULE, web_page_host, 50),  ...

एक आइटम को मुख्य व्यवस्थापक मेनू में जोड़ें:

 web_menu_host(Acc, Lang) ->  Acc ++ [{"mod_restrictions", ?T("Restrictions")}].

और मॉड्यूल पृष्ठ ही:

 web_page_host(_,      #request{method = Method,            q = Query,            path = ["mod_restrictions"],            lang = _Lang}) ->  case Method of    'POST' -> %% Handle database query      case lists:keyfind("act", 1, Query) of        {"act","add_usrgrp"} -> %% add user to group          {"usr",NewUser} = lists:keyfind("usr", 1, Query),          {"grp",NewGroup} = lists:keyfind("grp", 1, Query),          ?INFO_MSG("mod_restrictions: ADD NewUser=~p NewGroup=~p", [NewUser, NewGroup]);        ...        _ -> none      end;    _ -> none  end,  Res = [?XC("h1", "Restriction module manager"),      ?XE("table",[        ?XE("tr",          [?XC("th","Users"),?XC("th","Groups")]        ),        ?XE("tr",          [?XAE("td",[{"style","vertical-align:top;"}],web_user_list()),?XAE("td",[{"style","vertical-align:top;"}],web_group_list())]        )]      )     ],  {stop, Res}; web_page_host(Acc, _) -> Acc.

यहां हम पहले उपयोगकर्ता समूहों की सूची को बदलने के लिए POST अनुरोधों को संसाधित करते हैं, फिर निम्न HTML कोड वापस करते हैं:

 <h1>Restriction module manager</h1> <table><tr><th>Users</th><th>Groups</th></tr><tr><td style="vertical-align:top;">  - <form action="" method="post"><input type="text" name="usr" value=""/><input type="text" name="grp" value=""/><input type="hidden" name="act" value="add_usrgrp"/><input type="submit" name="btn" value="Add"/></form></td><td style="vertical-align:top;">  - <form action="" method="post"><input type="text" name="grp" value=""/><input type="text" name="dest" value=""/><input type="hidden" name="act" value="add_grpdest"/><input type="submit" name="btn" value="Add"/></form></td></tr></table>

सभी HTML पीढ़ी के कार्यों को ejabberd_web_admin.hrl फ़ाइल में पाया जा सकता है

डेटाबेस के साथ काम करें

सबसे आसान तरीका यह है कि इज़बर्ड के साथ मनेसिया डेटाबेस का उपयोग किया जाए।

हमें 2 तालिकाओं की आवश्यकता है: एक समूह में उपयोगकर्ताओं को शामिल करने के लिए, और दूसरा समूहों के अधिकारों को कॉन्फ़िगर करने के लिए।
तालिका संरचना को इरलांग रिकॉर्ड का उपयोग करके वर्णित किया गया है।

 -record(restrictions_users, {usr, grp}). -record(restrictions_groups, {grp, dest}).

हमने उपयोगकर्ता JID और समूह फ़ील्ड के साथ प्रतिबंध_सर्स रिकॉर्ड और समूह और दिशा फ़ील्ड (जहाँ आप संदेश भेज सकते हैं) के साथ प्रतिबंध_ रिकॉर्ड्स बनाए।

Mnesia तालिकाओं के साथ काम करने के दो तरीके हैं: लेनदेन और गंदे तरीके। दूसरा तरीका तेज़ है, लेकिन डेटाबेस की अखंडता की गारंटी नहीं देता है। संदेशों को संसाधित करते समय हम इसका उपयोग करेंगे।

टेबल निर्माण

अब, स्टार्ट फंक्शन में, इन रिकॉर्ड्स के अनुरूप टेबल्स बनाएं। जब तक विशेष रूप से ऐसा नहीं किया जाता है, तब तक वे मॉड्यूल को फिर से शुरू करने पर अधिलेखित नहीं होंगे।

 mnesia:create_table(restrictions_groups, [{disc_copies, [node()]} , {attributes, record_info(fields, restrictions_groups)}, {type, bag}]), mnesia:create_table(restrictions_users, [{disc_copies, [node()]} , {attributes, record_info(fields, restrictions_users)}, {type, bag}]),

अन्य बातों के अलावा, यहां हम इंगित करते हैं कि तालिका की एक प्रति हार्ड ड्राइव पर संग्रहीत है (डिफ़ॉल्ट रूप से, तालिकाओं को केवल रैम में संग्रहीत किया जाता है)। बैग टेबल के प्रकार का अर्थ है कि फ़ील्ड में मान अद्वितीय नहीं हो सकते हैं, लेकिन तालिका में प्रत्येक रिकॉर्ड अद्वितीय है।

तालिका से चुनें *

व्यवस्थापक पैनल में, हमें संपूर्ण तालिकाओं को प्रदर्शित करने की आवश्यकता है। ऐसा करने के लिए, आप इस डिज़ाइन का उपयोग कर सकते हैं:

 mnesia:dirty_match_object(mnesia:table_info(,wild_pattern))

यह हमें सभी तालिका प्रविष्टियों की सूची लौटाएगा। इसके अलावा, उदाहरण के लिए, सूचियों का उपयोग करना संभव होगा : HTML सूची से एक लेबल बनाने के लिए मानचित्र / 2 फ़ंक्शन।

शामिल हों

संदेशों को संसाधित करते समय, हमें उपयोगकर्ता (usr) और अनुमतियों (भाग्य) के बीच पत्राचार निर्धारित करने के लिए तालिकाओं में शामिल होना होगा। हम इसके लिए qlc मॉड्यूल का उपयोग करते हैं:

 Ftemp = fun() ->  Qvve = qlc:q([allow || U <- mnesia:table(restrictions_users),              G <- mnesia:table(restrictions_groups),              (U#restrictions_users.usr == FromUsr++"@"++FromDomain) and              (U#restrictions_users.grp == G#restrictions_groups.grp) and (                (G#restrictions_groups.dest == "all") or                (G#restrictions_groups.dest == ToDomain) or                (G#restrictions_groups.dest == ToUsr++"@"++ToDomain)              )        ]),  qlc:eval(Qvve) end, ?INFO_MSG("mod_restrictions: allow? ~p", [mnesia:transaction(Ftemp)]),

यदि उपयोगकर्ता से किसी ऐसे समूह में है जिसके पास सभी अनुमति है, तो उपयोगकर्ता को डोमेन पर लिखने की अनुमति दें, या स्वयं उपयोगकर्ता को लिखें, फिर क्वेरी {atomic, [allow, ...]} लौटाता है।

मॉड्यूल पैरामीटर

हम उदाहरण के लिए, कनेक्शन स्ट्रिंग की जगह, ejabberd.cfg सेटिंग्स फ़ाइल से मॉड्यूल में पैरामीटर पास कर सकते हैं:

 {mod_restrictions, [{deny_message,"    :("}]}

संदेश के अवरुद्ध होने पर हम उत्तर देने वाली मशीन का पाठ पैरामीटर में भेजेंगे।
मॉड्यूल में, get_module_opt फ़ंक्शन का उपयोग करके पैरामीटर मान प्राप्त किया जाता है:

 gen_mod:get_module_opt(Host, Module, Opt, Default)

किसी मॉड्यूल से संदेश भेजना

 Attrs = [{"type",Type},{"id","legal"},{"to",To#jid.user++"@"++To#jid.server++"/"++To#jid.resource},{"from",From#jid.user++"@"++From#jid.server++"/"++From#jid.resource}], Els = [{xmlcdata,<<"\n">>},{xmlelement,"body",[],[{xmlcdata,list_to_binary(Message)}]}], DenyMessage = {xmlelement,"message",Attrs,Els}, ejabberd_router:route(From,To,DenyMessage)

हम on_filter_packet पैरामीटर से From और To वैरिएबल लेते हैं, और वे jid प्रकार की प्रविष्टियों का प्रतिनिधित्व करते हैं।

निष्कर्ष

मॉड्यूल का पूरा पाठ यहां देखा जा सकता है ।
इस लेख को आधार के रूप में लिया गया है।

Ejabberd के लिए एक मॉड्यूल लिखना