Patch 1

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 
+<img src="https://i.imgur.com/oyGtyOj.jpeg">
+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"
+```

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 
 
 @author: widhi
 """

README.md

@@ -1,9 +1,9 @@
-# Distributed Systems Practice - Containerized
+# LK01: Lingkungan Praktik Mandiri + Ujicoba <i>Messaging Protocols</i>
 
-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
+<br> Sistem Terdistribusi A
+
 
 ## Sections & How to Run
 

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
+<img src="https://i.imgur.com/elHDASY.jpeg">

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())
+```
+<img src="https://i.imgur.com/mlT2HqV.jpeg">

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
+<img src="https://i.imgur.com/zG551ja.jpeg">

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
+```
+<img src="https://i.imgur.com/rQBwRlN.jpeg">

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")
+```
+<img src="https://i.imgur.com/zxma0ms.jpeg">

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.
+<img src="https://i.imgur.com/qIaJIXk.jpeg">
+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.

upcall/README.md

@@ -0,0 +1,26 @@
+# Upcall
+pola komunikasi antar client dan server, dimana server tidak hanya merespons permintaan client secara pasif, tetapi juga mengirimkan callback kepada client. Pada pengujian ini, mekanisme upcall terjadi ketika server menerima pesan dari client,  setelah itu server langsung mengirimkan balasan khusus berupa ;
+```
+"Upcall event: Processing " + data
+```
+Ini merupakan callback yang dikirimkan dari server ke client. Contohnya, ketika user mengirimkan pesan '1' ke client, maka server akan menerima pesan tersebut dan mengemasnya menjadi ;
+```
+Received from client: 1
+```
+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()  
+```
+<img src="https://i.imgur.com/DbOqtzz.jpeg">