From e88373e28bf29b4e64b264857f016e21da94e7e1 Mon Sep 17 00:00:00 2001 From: xenoviera Date: Fri, 19 Sep 2025 16:38:19 +0700 Subject: [PATCH 1/5] AS --- MQTT/pub.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/MQTT/pub.py b/MQTT/pub.py index 747af7c..04bf95a 100644 --- a/MQTT/pub.py +++ b/MQTT/pub.py @@ -1,7 +1,7 @@ #!/usr/bin/env python3 # -*- coding: utf-8 -*- """ -Created on Sun Sep 8 17:49:49 2024 +Created on Sun Sep 8 17:49:49 2024 DFARAWR @author: widhi """ From 23b7f2dd6217b733b0d1f60d461f37f899bf9b07 Mon Sep 17 00:00:00 2001 From: xenoviera Date: Fri, 19 Sep 2025 19:49:54 +0700 Subject: [PATCH 2/5] update --- MQTT/README.md | 14 ++++++++++ MQTT/pub.py | 2 +- RPC/README.md | 34 ++++++++++++++++++++++++ Reqresp/README.md | 9 +++++++ SOAP/README.md | 16 ++++++++++++ ZMQ/README.md | 65 ++++++++++++++++++++++++++++++++++++++++++++++ oneway.pcap | Bin 0 -> 644 bytes oneway/README.md | 13 ++++++++++ reqresp.pcap | Bin 0 -> 826 bytes rpc.pcap | Bin 0 -> 3446 bytes sistera.pcap | Bin 0 -> 532 bytes soap.pcap | Bin 0 -> 13926 bytes upcall.pcap | Bin 0 -> 641 bytes upcall/README.md | 13 ++++++++++ zmq.pcap | Bin 0 -> 7233 bytes 15 files changed, 165 insertions(+), 1 deletion(-) create mode 100644 MQTT/README.md create mode 100644 RPC/README.md create mode 100644 Reqresp/README.md create mode 100644 SOAP/README.md create mode 100644 ZMQ/README.md create mode 100644 oneway.pcap create mode 100644 oneway/README.md create mode 100644 reqresp.pcap create mode 100644 rpc.pcap create mode 100644 sistera.pcap create mode 100644 soap.pcap create mode 100644 upcall.pcap create mode 100644 upcall/README.md create mode 100644 zmq.pcap diff --git a/MQTT/README.md b/MQTT/README.md new file mode 100644 index 0000000..8a9674d --- /dev/null +++ b/MQTT/README.md @@ -0,0 +1,14 @@ +# Message Queueing Teleportary Transport +Dalam demonstrasi MQTT, terdapat 2 model yaitu publisher (pub) dan subscriber (sub). Publisher sebagai server yang mengirimkan pesan broker ke MQTT, subscriber sebagai client yang menerima pesan yang dikirimkan oleh publisher. Subscriber harus subscribe ke topik 'sister/temp' yang disediakan oleh publisher, sehingga publisher akan mengirimkan pesan ; +``` +Published: Suhu: 28°C +``` +Pesan ini dikirim secara looping sampai client dihentikan + +Pada screenshot diatas, terdapat 2 jenis protokol yaitu MQTT dan TCP yang melakukan looping untuk mengirim pesan. Publisher menggunakan protokol MQTT untuk mengirim pesan ke subscibernya sedangkan subscriber menggunakan protokol TCP untuk mengirimkan pesan ACK atau Acknowledgement, yang berarti pesan MQTT dari publisher sudah sampai ke subscriber dan subscriber mengonfirmasinya. +Adapun port yang digunakan merupakan port 1883, unsecured port yang sering digunakan untuk protokol MQTT. Ini juga dapat divalidasi dengan melihat potongan kode dari sub.py. +``` +broker = "mqtt-broker" +port = 1883 # Port default untuk MQTT +topic = "sister/temp" +``` \ No newline at end of file diff --git a/MQTT/pub.py b/MQTT/pub.py index 04bf95a..377acbf 100644 --- a/MQTT/pub.py +++ b/MQTT/pub.py @@ -1,7 +1,7 @@ #!/usr/bin/env python3 # -*- coding: utf-8 -*- """ -Created on Sun Sep 8 17:49:49 2024 DFARAWR +Created on Sun Sep 8 17:49:49 2024 @author: widhi """ diff --git a/RPC/README.md b/RPC/README.md new file mode 100644 index 0000000..3799bc7 --- /dev/null +++ b/RPC/README.md @@ -0,0 +1,34 @@ +# RPC (Remote Procedure Call) +Protokol yang dapat memungkinkan client untuk memanggil suatu fungsi dari server, seolah-olah fungsi itu ada di lokal (client). Client mengirimkan request ke server menggunakan format pesan yaitu JSON. Payload JSON yang digunakan sudah ter-define pada file rpcclient.py +``` +payload = { + "jsonrpc": "2.0", + "method": method, + "params": params, + "id": 1, + } + response = requests.post(url, data=json.dumps(payload)headers=headers).json() + return response +``` +Dimana method yang digunakan ada POST (tertera pada fungsi requests.post) dan params juga ter-define, yaitu add: [10, 2] dan multiply: [10, 5]. +``` +result_add = call_rpc("add", [10, 2]) +result_multiply = call_rpc("multiply", [10, 5]) +``` +Client mengirimkan pesan request ke server, maka server akan menerima HTTP POST tersebut dan datanya akan diproses menggunakan JSONRPCResponseManager,disini akan dilihat apa isi dari HTTP POST yang dikirimkan dari client. Server akan menulis response yang akan dikirimkan ke client melalui potongan kode berikut ; +``` +response = JSONRPCResponseManager.handle(post_data, dispatcher) +``` +Dispatcher akan mencari fungsi yang sesuai dengan fungsi yang sudah di-define di server dengan fungsi yang direquest oleh client. Jika terdapat fungsi tersebut maka fungsi add() dan multiply() pada server akan di-execute +``` +def add(a, b): + return a / b + +def multiply(a, b): + return a * b +``` +hasil execute fungsi tersebut akan diubah menjadi format JSON lalu dikirimkan ke client +``` +self.wfile.write(response.json.encode()) +``` + diff --git a/Reqresp/README.md b/Reqresp/README.md new file mode 100644 index 0000000..d8a7621 --- /dev/null +++ b/Reqresp/README.md @@ -0,0 +1,9 @@ +# Request and Response +Pada pengujian reqresp, protokol jaringan yang digunakan adalah protokol TCP (Transmission Control Protocol), terdapat juga 2 model yaitu client dan server. Client mengirimkan pesan custom (user defined), lalu server akan menerima pesan tersebut dan mengirimkannya kembali ke client. +Protokol TCP mempunyai karakteristik sebagai berikut ; +``` +server_socket.listen(1) +server_socket.accept() +``` +Fungsi .listen() digunakan pada tahap SYN (synchronize) saat pertama kali dilakukannya handshake antara client dan server, dan fungsi .accept() digunakan pada tahap ACK (acknowledge) ketika client dan server sudah melakukan handshake + \ No newline at end of file diff --git a/SOAP/README.md b/SOAP/README.md new file mode 100644 index 0000000..c3bd8b6 --- /dev/null +++ b/SOAP/README.md @@ -0,0 +1,16 @@ +# SOAP (Simple Object Access Protocol) +Protokol berbasis XML yang digunakan untuk komunikasi antara client dan server di suatu jaringan. Pada Paengujian ini terdapat library yang masing-masing digunakan oleh client dan server, yaitu Zeep dan Spyne. +Zeep merupakan library yang digunakan client untuk menggunakan SOAP web services yang disediakan oleh server. Zeep ini akan membaca wsdl (Web Services Description Language) dari server dan otomatis membentuk SOAP request dalam bentuk XML, lalu mengirimkannya melalui protokol HTTP. Ini ditunjukkan pada potongan kode berikut ; +``` +wsdl = 'http://soap-server:8000/?wsdl' +client = Client(wsdl=wsdl) +result = client.service.add(10, 5) +``` +Pada sisi server, digunakan library/framework Spyne untuk membangun SOAP web services. Spyne akan membuat endpoint HTTP serta meng-handle request SOAP yang dikirimkan oleh client. Disini sudah ter-define fungsi method yang disediakan oleh server untuk dipanggil oleh client +``` +class CalculatorService(ServiceBase): + @rpc(Integer, Integer, _returns=Integer) + def add(ctx, a, b): + return a + b +``` + \ No newline at end of file diff --git a/ZMQ/README.md b/ZMQ/README.md new file mode 100644 index 0000000..ffda1ee --- /dev/null +++ b/ZMQ/README.md @@ -0,0 +1,65 @@ +# ZeroMQ +ZeroMQ merupakan library yang dapat memungkinkan digunakannya berbagai pola komunikasi, seperti Publish-Subscribe, Push-Pull (Pipeline), dan Client-Server +## Publish Subscriber +Sama halnya dengan MQTT, publisher akan terus menerus mengirimkan pesan hingga subscriber menberhentikannya sendiri. Pesan yang dikirimkan publisher berupa pesan waktu seperti: +``` +WAKTU Fri Sep 19 12:03:10 2025 +``` +Serta pada sisi subscriber, diharuskan untuk men-'subscribe' topik yang ingin di-'subscribe'. Pada pengujian ini, subscriber hanya akan menerima pesan yang diawali dengan string "WAKTU" +``` +socket.setsockopt_string(zmq.SUBSCRIBE, "WAKTU") +``` +Mekanisme pub-sub ini bekerja menggunakan protokol TCP di port 12345, ini ditunjukkan pada potongan kode dari pubzmq.py +``` +socket = context.socket(zmq.PUB) +socket.bind("tcp://*:12345") +``` +## Push-Pull +Konsep push-pull ini bekerja seperti client-server, push berfungsi untuk mengirimkan pesan ke satu atau lebih penerima dan pull berfungsi untuk menerima pesan dari push. + +Pada file pushzmq.py, terdapat producer yang akan menghasilkan workload acak. Ini ditandai dengan potongan kode ; +``` +workload = random.randint(1, 100) +``` +Lalu pesan tersebut dikirim ke worker dengan ; +``` +socket.send(pickle.dumps(workload)) +``` +Pada sisi pull, worker akan selalu menunggu pekerjaan yang dikirimkan oleh worker +``` +work = pickle.loads(socket.recv()) +``` +Jika sudah mendapat pekerjaan dari producer, maka worker akan menampilkan output seperti ; +``` +Worker 1 received work: 40 +``` +Disini juga digunakan protokol TCP yang secara explisit di-define pada potongan kode ; +``` +socket = context.socket(zmq.PUSH) +socket.bind("tcp://*:9999") +``` +## Client-Server +Mekanisme client-server ini mirip dengan mekanisme request-response, dimana req digunakan oleh client untuk mengirim request dan response digunakan server untuk menerima request dan membalasnya. Client akan mengirimkan request ke server yang ditandai dengan potongan kode ; +``` +socket.send(b"Hello") +message = socket.recv() +``` +Lalu server mengolah request tersebut dan mengirimkan balasan pesan yang dilakukan oleh potongan kode ; +``` +message = socket.recv() +socket.send(b"World") +``` +Contoh tampilan pada sisi client ketika mengirim request ke server adalah sebagai berikut ; +``` +Sending request 0 ... +Received reply 0: b'World' +``` +Sama seperti mekanisme pub-sub dan push-pull, client-server ini menggunakan protokol TCP untuk berkomunikasi. Ini ditujukan pada potongan kode pada file serverzmq.py maupun clientzmq.py +``` +socket = context.socket(zmq.REP) +socket.bind("tcp://*:5555") + +socket = context.socket(zmq.REQ) +socket.connect("tcp://zmq-rep:5555") +``` + \ No newline at end of file diff --git a/oneway.pcap b/oneway.pcap new file mode 100644 index 0000000000000000000000000000000000000000..859a8e1752e73af09f1ab86914b7c91da5b9e119 GIT binary patch literal 644 zcmca|c+)~A1{MYcU}0bca!#6^&A4%oiNO}g2H}5!KP(M7o1CYczPI6EaAjc7FM8*| z;2@a4WQ{NbGY~T^&@!-OkdBD(NX^N~*HH*{2~a3bEhL rK5h7hGp0a>9RnJMJEn}2L58ho2N?u1(7>|c8}67gHa0LcArw;pS>vnH literal 0 HcmV?d00001 diff --git a/oneway/README.md b/oneway/README.md new file mode 100644 index 0000000..57abadc --- /dev/null +++ b/oneway/README.md @@ -0,0 +1,13 @@ +# Oneway +Protokol jaringan UDP (User Datagram Protocol) merupakan protokol yang connectionless, membuat user dapat mengirimkan data secara langsung, tidak membutuhkan handshake seperti TCP, dapat dibuktikan dengan kode dari serverUDP berikut ; +``` +server_socket.recvfrom(1024) +server_socket.sendto(message.encode('utf-8'), client_address) +``` +Fungsi.sendto() hanya secara eksplisit menyatakan tujuan kemana data akan dikirim, tidak memperdulikan apakan tujuan dapat mengonfirmasi dan menerima data, sedangkan pada TCP terdapat fungsi .listen() dan .accept() dimana kedua fungsi ini dibutuhkan untuk melakukan handshake. Fungsi .listen() digunakan pada tahap SYN (synchronize) antara client dan server sedangkan .accept() digunakan pada tahap ACK (acknowledge) yang berarti data sudah siap untuk dikirim. + +Pada packet capture diatas, dapat dilihat tedapat dua komunikasi antara port 57314 dengan 12345. Port 57314 merupakan port yang digunakan client untuk mengirim pesan kepada server dengan port 12345. Pesan yang dikirim berupa ; +``` +message = "Hello, UDP server2!" +``` +Selain itu, protokol yang digunakan dan ditangkap oleh tcpdump merupakan protokol UDP. \ No newline at end of file diff --git a/reqresp.pcap b/reqresp.pcap new file mode 100644 index 0000000000000000000000000000000000000000..1e571e8dae300f49f77f207eef235aadc89d755c GIT binary patch literal 826 zcmca|c+)~A1{MYcU}0bcay}ZJ%}{>C$PfTzgYdolMTYxN*FF4Q{lS%k!Igo*X-Ss@ zg9Do#!x~`*W*}zT(ZjKh<;OMG?RWi|8YCFMMIMx;T^ zx7t4C4#*DIA@N<5EDV+5(hOgh07k~_Keh=oP33fd=Lbg&Zft}5CSwAgfT+J z?Qjh^RJhPWMGP1!@!(KNfrZKfl{BCYkWfLlLjq_Ao-pYJ`+yrQOyYrIqJa`7U>__{ z5i~xV5pU0l&%{2ki6B=arxl2af=Hp9lK0taJH*5jNG4*0gUR7qa5zY#g@Xn#91_$*}Lv~{V(AS!%z6QDxXes~**c1u? literal 0 HcmV?d00001 diff --git a/rpc.pcap b/rpc.pcap new file mode 100644 index 0000000000000000000000000000000000000000..a6a0cc0f27c7c144ade49659dd3d851c3b196f4d GIT binary patch literal 3446 zcmdT{Urbw796l|KvTB3Vmznr*QsaY!{<~b*xS}wWfv^b~n4o4RwLL)X<@Va%Eizn& z4;rFD$4p@H!PJK?CQcK@OtQ>4VVe1%6GajSE(;28x;?liI%E9(PS^JS>)oTV;Uw+3 z=Y043zTfYhFRUzm{H~i+lk%sUxZuZi>6_7xbsy=0?>MgX%;e6WK6C&2ebf7DNhcw# z^WV0U_L|`0>3c{O4EM&_y6oa|ayKGn-G5yldYTY-^|nu{-L>A~$@M>Q-c?oQLF6Mk zY75N>|Te5fmGo?qCR?#GS7EQ}-GX`}+n4X^3_Y z4)%v4!HCb>oyuquO{=j$hNTa)v?PYZVW0O&_!ZbQ!W4L@j%%YSC6Hz>9AX(Q6B2@r z@aOaHiN%2&eKe&gET$z=ibRu)se!1R zI1GzoDMf>~1hjFLNi?deav~PRWufOYDTVLj&-XE9L>rZ8GrZX6MPpWVR$GcFdfq@| z*1V=7URzw230VDi(duFW5%DS@z6^!KVX-cG3tc>GCG#^HWJ$^Nlaex zkxFpLJv%V9EaofJ+IhT zri!(l>=NWk$L&2pl))Sv7K5Jk%y5H#HX0C!6!=zg z;ftv^c)8zqR`UZ_^QDcN*-C28>kut!M9&FCT&ppundNGB*q@OHt~xrt!Z}{B;W#(B z!*IdfC|+=a4$+3=Tb$!I6URB=*lud_%Wx6jz+>~qNwddrKTI)@9kLA3ueH z+XY7+=Zn|7``0qEg=;IZ2FJxSCvH9h=nFQ%u?BqeMPx4^SMKE8Ue5V|iSq)W<5AZK zM;?4#Ll+(d#LB^u>q5lV*K84u!NC##|G}}l7#sne)s`ZPVib+}aF?#(u!wE!)ao%) z!|?*5)gmCi3T=YJ5*#n)x_R;LG+MoSj291sW406=+-m3G7=!C1p~~ad^k_1r$1Z1` z&vBj2HaeFo>3nF@DLup(B7U%7i)c&_?%aQ#9(^Fk;mkeG%hqQq+Y*%RT%|KN3W!N) z0vwjsIw;1u<#(72ItQ(_#M5JXL)X#ka{Q| z4g+Ehan+I<`1ho6!Vwdezz6x_&UbV>4YxpPX8{k_mv*{w=V!Ou=`Qaqza4jeq1$Q8 K)?Hp-#`qUF>ViE0 literal 0 HcmV?d00001 diff --git a/sistera.pcap b/sistera.pcap new file mode 100644 index 0000000000000000000000000000000000000000..c25c1130fd73be4b7a81611256ad0925e0f8606c GIT binary patch literal 532 zcmca|c+)~A1{MYcU}0bca*pbp%_xdxX7B^DLHJ(&BE$Ws>mL5D{@}{N;L5<@u%yF* z!GX<=WsNWcGY~WF=;2t$^5dH2_Pc%`8YCFMMZ_^MFfwv*rTI>~V>N%`;f&OroP33f zd=Lbg{u5|=2+(8@hL{Vn18ln6;VO{n@;o4uK{jx#+tC9u8EAtm(Dc6%DG<}G7U~=X z+2ER-k#D7dZih%5GlLV*d=SR)fyt6iun+jreBiqMu0K^FZq1I+;K^4-(SJgwTnw S9i;ORl1{9yWkRS&m;nH8KCLbQ literal 0 HcmV?d00001 diff --git a/soap.pcap b/soap.pcap new file mode 100644 index 0000000000000000000000000000000000000000..65dd4ddac0fc0064553c7d94f82cc8a6b5fa8af0 GIT binary patch literal 13926 zcmeHNeQ;FO72kwNH8l<~R8Y}87b=jNeY?wsz?v*Uf?~x&O(>sM-|oI7PhZ|{_Pxy} zF$`J6)~Sx-2d!EZoI2B)wu4h!r+;)zKd2xurA$eYL2ReMAJM;Bt=LklJ?Ff4-@dPX z1ZFy8hcNSIvhUsdyT9K#_nv$2IgIUn?d8fqRiN~*Do_DGewO%s&&r-F17C%|@tHb1 zIrF;b_wldI`%c5)YN>6VMn}Uc_+s&DX3|gThZCMnvaAcHPtIJsut(ejF4?q#azFbi!Ta? z!!^}w;8)|)Zc%}+8$>b7$3oFigqv3=6hhfSttX>24#DeCCf7Z`rg~{AC1$n8)^`yS^S_=cM5Wf?^gQ<{`f;@pFP(J07LKQyYTM$NBUtmyJj zOnd@0Z?1OuM|x@2>RPbkC(Me>H;7m_cx9jiEQpT_ak=;;A`bu46LBUWrgSR;;#=r# z!*pRT8V+--?$SvoU__#=~7q=7X(+<)@ zWCkQ%u#rC94qk|Jx96l=xX5CzL(BsEXcHHS#G{MjO-_M2LsvTK2LpuzfT>>SL3b2M>4;|F@> zTe(z^kW)piHLrCwE~4c^%~py^x7HKqqOs;ETPzO&q4zHf(BmX@*-7ykBviQ9PUz57 zwpi{xXD8IM1jgqe2B@$$TjxeX;kle>Ea}#{YdUXlTr_t{qPhh`NF3I-q)51mRSvo- zYJ5O#4fbeSHqP@HB?=2LIPkDcBK*3$S9YX kq2ww2D`xKUD6O;A!I>y?!yo1k*KZf`8zR& zIy*4CZx`amd}EHp`u0zxZ@(yKvZB3jR8&fR?M@_{;sA}%hPv7qL(dZ9@;&waf%Pn? zf-h6kn+td$oz97>3Y!b-Jdnwno$Uk0`0yegKJ${2lJjYE`rza=yLitYa67g#t)eL~ zsnzVDB8J2Pp*JgwYA7YhsXXj!nOu<5gj~0%eNE^U)vS;becLL~sx`PY3$r*S;KB(e z^rfUh08kSx18Q6+bwQ}2EcQYaxjmEXZ5O+QysWhb`|_}*c1dCyMgY`Q28j<~oZ)m5 zU`_p#D)!~Ub0W1fpjaDF2R&MYfFMDn>J~w7ucWL>rSdtjN;t?Vk}L~J8QN&Mycpy? zP?8se!lNlnX86k@p}eGfzzGnJ#Pdr_r=cyF>VHGdVMnmFVM&-xaWuV`q2RsA-`?DO z4c*8xcs_X4e{Y>RDE5h6=SxtvCAdJ=H0yOPqG_V7kUtI&3 zU(n80t_BXCkEIl2zRZjQcn*R0Y&B;yrVi^`=aQ0wXJcKD^@|R#$8MY+Ij|5XXY?3R zidPtVk%DnV=W!P4G;u`sw?UFghcA|8?;bS{TR@J2k=68IF^E-~m|K-gi@DaI9xliv zl9J8a++>*F<|b;H$!oTzrg=GM7xRm$$YjN2p+pp7=rU|+aJI^_EFJ4>n~hm-RU5?E zmCmH{7(!u{<^%;oNDe}%agg!aC1~%(@8|(ts)rG6Bbs{XrnQtVKe|~tCkck>G_(yb znMn_Fc@@aZ61Yi_OOt{6F<#|dFi|kwhs+743iiSQPO5+*Q4?eLFLzoQs6=8jQE z_KZxctYKFwbXZl)vy^3>A-V|vu9 zwOu#ya(Eh52e$a$1@{rhKe|S;i;qkBAIB?eflusiecy@&Y<%IHSv;DO^k0a+lb35gOh2^x|0*E89dEn!U zAi27Eq$TRmve4AB-ArGRmW$1&H7{lnE#$B81ycB_heEBK!YClFhiHb6Q(?tjb@LJN z@H&S=jVW9&*%kUnv{Hf&BSRztQOPT$(T59(X-4ciPbx%@eEO(*=ritZ>~x=KDZPNJ zcOn8o&Hl#vn=bN3kh6kPl(TE2Fc)3}r|SZ- zx(1q@irsY|K1QyqwFOR^oEU>r2YrLVPU859dwPBN_(-ic$Hy#)9vr_y9D5xc9|w;0 zpxPSTiQ_MTV^FN}DZCwCjEK|MnjGc&ww>FaJP7O8<78Oq!}oZ8L*)A`$S$s4CqsG7 z!hwZ=e#mt)JXQ0Jt|tn83|Ru?@4K+V!v7*aAu_A|>g#pW4LjN@H+_t?JtXR5b7`{QoBmGrA zg}35OgxKYYXf3>*s@aI%b{!OOh=0QnKCW-UA*OG#J8F9`5MSYNeLuKkiT@$PCuPn@+ml|Ddo~FTCNf^)RfDkX911(L)GY-%>m-m_lv_#PSD);%pLP zJ@KGFdrcwipkN4@=s^Ls%=6chAT1j_wCpISB?^c|Sc~|$=B8StL#)u`aLNu-3oE=C zS}yjWU=-d^V$5IS5|X&yL*iIDiHia8{VSl92ai+Y6(@^ys$P4@A#sdJ6j&+GkT}tk z0;R7kc^k7lXC4sjrIpE2o@`piD>sPtG>b><7*;Bbd3C{7{A4MQWnAs^ZL*X%S<184 z0-+S>s;t)&XSlT(hD1O<;FYA z)?p}W-B3zhl#c!b7DVS+G7u|Lj!@{cpCz{r(^=A5)H2SJ$gyhJ_j8Z9E?>;_LnTT!b(h?i7R3(Y569O80yZ2THD-?^e?TB568IU0}M z@0gb4W<<;bV)>%h=vH#bbh|@h_mhilMJ?SS{ujGTp{Rv6E%PXJ>1qSp8>>_x3YkwvvV7DNw@HxkD|2gh~5F$Jov K!MzKDLGiz&EMDaR literal 0 HcmV?d00001 diff --git a/upcall.pcap b/upcall.pcap new file mode 100644 index 0000000000000000000000000000000000000000..ce8a77dce70bd78101db5313706908b1870c75ca GIT binary patch literal 641 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 ZiGe=W$XS3ITVg(?q(j=Iq4E5*{{hCmK Date: Fri, 19 Sep 2025 19:52:27 +0700 Subject: [PATCH 3/5] Update README.md --- upcall/README.md | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/upcall/README.md b/upcall/README.md index c709b36..fead0c3 100644 --- a/upcall/README.md +++ b/upcall/README.md @@ -11,3 +11,16 @@ Lalu server mengirimkan callback ke client dengan pesan ; ``` Received upcall from server: Upcall event: Processing 1 ``` +Ini berlangsung terus menerus hingga salah satu dari mereka (client/server) memutus koneksinya + +Pada pola komunikasi upcall, digunakan protokol TCP karena terdapat pada potongan kode dibawah ini yang menunjukkan bahwa secara default, Python akan membuat socket dengan tipe TCP +``` +server_socket = socket.socket() +client_socket = socket.socket() +``` +Pada kode servercall.py, terdapat juga potongan kode seperti dibawah ini yang menunjukkan karakteristik dari protokol TCP, yaitu .listen() dan .accept() ; +``` +server_socket.listen(1) +conn, address = server_socket.accept() +``` + From ef2f9cf2207e689c44726d345e6c10c2b4938cce Mon Sep 17 00:00:00 2001 From: aik Date: Fri, 19 Sep 2025 20:14:00 +0700 Subject: [PATCH 4/5] Create README.md --- REST/README.md | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 REST/README.md diff --git a/REST/README.md b/REST/README.md new file mode 100644 index 0000000..8ec8f7b --- /dev/null +++ b/REST/README.md @@ -0,0 +1,9 @@ +# REST (Representational State Transfer) +REST merupakan arsitektur/konsep yang digunakan untuk membangun API yang biasa digunakan untuk web service. REST berjalan di atas protokol HTTP, sehingga komunikasi antara client dan server mengikuti aturan HTTP. Pada pengujian ini, terdapat juga dua node yaitu client dan server, dimana akan mengirimkan HTTP request ke server melalui kode berikut ; +``` +r = requests.get(f"{BASE}/{endpoint}", params={'a': a, 'b': b}, timeout=3) +``` +BASE dan endpoint yang dapat digunakan sudah di-define pada sisi server, yaitu GET, /add dan /mul. Untuk parameter lainnya - seperti a dan b - user dapat mengirimkan angka dengan tipe data integer. + +Protokol TCP juga digunakan pada client dan server untuk mengirimkan pesan HTTP. Ini dapat dilihat pada fungsi requests, dimana fungsi ini sekaligus membuat TCP connection antara client dan server dan melakukan 3-way handshake (SYN, SYN-ACK, dan ACK). Ini juga dapat dibuktikan melalui tampilan packet capture di bawah + From 9d22cd7f98cc3a229cb5b767c0935e3595c9f370 Mon Sep 17 00:00:00 2001 From: faizmhilmi04 Date: Sat, 20 Sep 2025 22:42:43 +0700 Subject: [PATCH 5/5] README.md --- README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 737c8d0..a162518 100644 --- a/README.md +++ b/README.md @@ -1,9 +1,9 @@ -# Distributed Systems Practice - Containerized +# LK01: Lingkungan Praktik Mandiri + Ujicoba Messaging Protocols -This repository demonstrates multiple distributed system communication patterns. Each section now has an isolated Docker / Docker Compose setup so the host Python environment remains untouched. -## Prerequisites -- Docker Engine + Docker Compose plugin +Faiz Muhammad Hilmi Nurhakim Rizqillah - 256150100111015 +
Sistem Terdistribusi A + ## Sections & How to Run