MQTT —
publish/subscribe'dan QoS'a.

# broker'a bağlan ve TÜM topic'leri dinle (wildcard #)
mosquitto_sub -h localhost -t "#" -v
# -v: topic adını da göster

# sadece belirli bir topic
mosquitto_sub -h localhost -t "sensors/temperature"

# mesaj yayınla
mosquitto_pub -h localhost -t "test/hello" -m "world"

# QoS 1 ile yayınla
mosquitto_pub -h localhost -t "sensors/temp" -m "23.5" -q 1

# retained mesaj
mosquitto_pub -h localhost -t "sensors/temp" -m "23.5" -r

# TLS ile bağlan (8883)
mosquitto_sub -h broker.example.com -p 8883 --cafile ca.crt -t "#"

# iyi yapılandırılmış topic hiyerarşisi
home/bedroom/temperature
home/bedroom/humidity
home/living_room/temperature
sensors/device_001/status
factory/line_3/machine_7/vibration
cmd/device_001/set_led

# sensors/+/temperature → sadece bir seviye
# eşleşir: sensors/bedroom/temperature
# eşleşmez: sensors/floor1/bedroom/temperature
sensors/+/temperature

# home/# → home altındaki her şey
# eşleşir: home/bedroom/temp, home/kitchen, home/living_room/a/b/c
home/#

# tüm status topic'leri (herhangi derinlikte)
mosquitto_sub -t "+/+/status"
mosquitto_sub -t "sensors/#"

# broker istatistikleri
mosquitto_sub -h localhost -t "\$SYS/#" -v
# $SYS/broker/clients/connected → bağlı client sayısı
# $SYS/broker/messages/received → alınan mesaj sayısı
# $SYS/broker/load/bytes/received → gelen byte/sn

# retained mesaj yayınla
mosquitto_pub -h localhost -t "sensors/temp" -m "23.5" -r

# retained mesajı sil: boş payload ile retain=True
mosquitto_pub -h localhost -t "sensors/temp" -m "" -r

import paho.mqtt.client as mqtt

CLIENT_ID = "sensor_001"
WILL_TOPIC = f"devices/{CLIENT_ID}/status"

client = mqtt.Client(client_id=CLIENT_ID)

# bağlanmadan ÖNCE will tanımla
client.will_set(
    topic=WILL_TOPIC,
    payload="offline",
    qos=1,
    retain=True
)

client.connect("localhost", 1883)

# başarılı bağlantıda "online" yayınla (retained)
client.publish(WILL_TOPIC, "online", qos=1, retain=True)

pip install paho-mqtt
# paho-mqtt >= 2.0 önerilir

import paho.mqtt.client as mqtt

# paho-mqtt >= 2.0: CallbackAPIVersion belirtmek zorunlu
client = mqtt.Client(
    callback_api_version=mqtt.CallbackAPIVersion.VERSION2,
    client_id="mydevice_001",
    protocol=mqtt.MQTTv311  # veya MQTTv5
)

# paho-mqtt < 2.0 (eski API — deprecated)
client = mqtt.Client(client_id="mydevice_001")

import paho.mqtt.client as mqtt
import json
import time
import random

BROKER   = "localhost"
PORT     = 1883
TOPIC    = "sensors/device_001"
CLIENT_ID = "publisher_001"

def on_connect(client, userdata, flags, reason_code, properties):
    if reason_code == 0:
        print(f"Broker'a bağlandı: {BROKER}:{PORT}")
    else:
        print(f"Bağlantı hatası: {reason_code}")

client = mqtt.Client(
    callback_api_version=mqtt.CallbackAPIVersion.VERSION2,
    client_id=CLIENT_ID
)
client.on_connect = on_connect

# LWT: beklenmedik kopma durumunda "offline" yayınla
client.will_set("devices/device_001/status", "offline", qos=1, retain=True)

client.connect(BROKER, PORT, keepalive=60)
client.loop_start()  # arka planda network döngüsü

# bağlantı bildir
client.publish("devices/device_001/status", "online", qos=1, retain=True)

try:
    while True:
        payload = json.dumps({
            "temperature": round(random.uniform(18.0, 30.0), 2),
            "humidity":    round(random.uniform(40.0, 80.0), 2),
            "pressure":    round(random.uniform(1000.0, 1020.0), 2),
            "timestamp":   int(time.time())
        })
        result = client.publish(TOPIC, payload, qos=1)
        result.wait_for_publish()
        print(f"Yayınlandı → {TOPIC}: {payload}")
        time.sleep(5)
except KeyboardInterrupt:
    pass
finally:
    client.publish("devices/device_001/status", "offline", qos=1, retain=True)
    client.loop_stop()
    client.disconnect()

import paho.mqtt.client as mqtt
import json

BROKER = "localhost"
PORT   = 1883

def on_connect(client, userdata, flags, reason_code, properties):
    if reason_code == 0:
        # bağlantı kurulunca subscribe — yeniden bağlanmada da çalışır
        client.subscribe("sensors/#", qos=1)
        print("Bağlandı, sensors/# dinleniyor")

def on_message(client, userdata, msg):
    try:
        data = json.loads(msg.payload.decode())
        print(f"[{msg.topic}] sıcaklık={data['temperature']}°C  "
              f"nem={data['humidity']}%  basınç={data['pressure']} hPa")
    except (json.JSONDecodeError, KeyError) as e:
        print(f"Parse hatası: {e} | ham: {msg.payload}")

def on_disconnect(client, userdata, flags, reason_code, properties):
    print(f"Bağlantı kesildi: {reason_code}")

client = mqtt.Client(
    callback_api_version=mqtt.CallbackAPIVersion.VERSION2,
    client_id="subscriber_dashboard"
)
client.on_connect    = on_connect
client.on_message    = on_message
client.on_disconnect = on_disconnect

client.connect(BROKER, PORT, keepalive=60)
client.loop_forever()  # bloklar, Ctrl+C ile dur

import ssl
import paho.mqtt.client as mqtt

client = mqtt.Client(
    callback_api_version=mqtt.CallbackAPIVersion.VERSION2,
    client_id="tls_client_001"
)

# CA sertifikası ile doğrulama
client.tls_set(
    ca_certs="/etc/ssl/certs/ca.crt",
    certfile=None,     # mTLS değil — sadece sunucu doğrulama
    keyfile=None,
    tls_version=ssl.PROTOCOL_TLS_CLIENT
)

# kullanıcı adı / şifre
client.username_pw_set("sensor_user", "güçlü_şifre")

client.connect("broker.example.com", 8883, keepalive=60)
client.loop_forever()

# Debian / Ubuntu
apt install mosquitto mosquitto-clients

# durum kontrol
systemctl status mosquitto

# verbose başlatma (test için)
mosquitto -c /etc/mosquitto/mosquitto.conf -v

# plaintext listener — yalnızca localhost
listener 1883 127.0.0.1

# anonymous bağlantıya izin ver (test ortamı)
allow_anonymous true

# log seviyesi
log_type all
log_dest file /var/log/mosquitto/mosquitto.log

# persistent session için mesaj kalıcılığı
persistence true
persistence_location /var/lib/mosquitto/

# yeni parola dosyası oluştur (-c), kullanıcı ekle
mosquitto_passwd -c /etc/mosquitto/passwd sensor_user

# mevcut dosyaya kullanıcı ekle (dosyayı yeniden oluşturmaz)
mosquitto_passwd /etc/mosquitto/passwd dashboard_user

# kullanıcı sil
mosquitto_passwd -D /etc/mosquitto/passwd eski_kullanici

listener 1883 127.0.0.1
allow_anonymous false
password_file /etc/mosquitto/passwd

# TLS listener — port 8883
listener 8883
cafile   /etc/mosquitto/certs/ca.crt
certfile /etc/mosquitto/certs/server.crt
keyfile  /etc/mosquitto/certs/server.key

# mTLS için (client sertifikası zorunlu)
require_certificate true
use_identity_as_username true

allow_anonymous false
password_file /etc/mosquitto/passwd

# CA key ve sertifika oluştur
openssl genrsa -out ca.key 4096
openssl req -new -x509 -days 1826 -key ca.key -out ca.crt \
    -subj "/CN=MQTT CA"

# sunucu key ve CSR
openssl genrsa -out server.key 2048
openssl req -new -key server.key -out server.csr \
    -subj "/CN=localhost"

# CA ile imzala
openssl x509 -req -days 365 -in server.csr \
    -CA ca.crt -CAkey ca.key -CAcreateserial -out server.crt

# test bağlantısı
mosquitto_sub -h localhost -p 8883 --cafile ca.crt -t "test/#"

# boot'ta başlat ve hemen başlat
systemctl enable --now mosquitto

# config değişikliği sonrası reload
systemctl reload mosquitto

# log izle
journalctl -u mosquitto -f

# 1. mosquitto başlat (ayrı terminal)
mosquitto -v

# 2. subscriber başlat (ayrı terminal)
python3 dashboard.py

# 3. publisher başlat (ayrı terminal)
python3 sensor_sim.py

# 4. Ctrl+C ile publisher'ı durdur — LWT "offline" yayınlanır

#!/usr/bin/env python3
"""Sensör simülatörü — bağımlılık yok: paho-mqtt + stdlib"""

import json
import random
import time
import paho.mqtt.client as mqtt

BROKER    = "localhost"
PORT      = 1883
CLIENT_ID = "sensor_sim_001"
BASE      = "home/sensors/sim_001"
STATUS    = f"devices/{CLIENT_ID}/status"
INTERVAL  = 5  # saniye

def on_connect(client, userdata, flags, reason_code, properties):
    if reason_code == 0:
        client.publish(STATUS, "online", qos=1, retain=True)
        print(f"[sim] Bağlandı → {BROKER}:{PORT}")
    else:
        print(f"[sim] Bağlantı hatası: {reason_code}")

client = mqtt.Client(
    callback_api_version=mqtt.CallbackAPIVersion.VERSION2,
    client_id=CLIENT_ID
)
client.on_connect = on_connect
# LWT: ani kopma → "offline" (retained QoS 1)
client.will_set(STATUS, "offline", qos=1, retain=True)

client.connect(BROKER, PORT, keepalive=30)
client.loop_start()

# broker'a bağlanmak için kısa süre ver
time.sleep(1)

seq = 0
try:
    while True:
        seq += 1
        payload = {
            "seq":         seq,
            "temperature": round(20.0 + random.gauss(0, 1.5), 2),
            "humidity":    round(55.0 + random.gauss(0, 5.0), 1),
            "pressure":    round(1013.25 + random.gauss(0, 2.0), 2),
            "ts":          int(time.time())
        }
        msg = json.dumps(payload)

        # telemetri: QoS 1, retained (son değer her zaman mevcut)
        client.publish(f"{BASE}/telemetry", msg, qos=1, retain=True)
        print(f"[sim] #{seq:04d} → {BASE}/telemetry")
        time.sleep(INTERVAL)

except KeyboardInterrupt:
    print("[sim] Kapatılıyor...")
finally:
    # graceful disconnect: LWT tetiklenmez, manuel "offline"
    client.publish(STATUS, "offline", qos=1, retain=True)
    time.sleep(0.5)  # mesajın gönderilmesi için bekle
    client.loop_stop()
    client.disconnect()
    print("[sim] Çıkıldı.")

#!/usr/bin/env python3
"""Terminal dashboard — sensör verilerini canlı göster"""

import json
import time
import paho.mqtt.client as mqtt

BROKER     = "localhost"
PORT       = 1883
CLIENT_ID  = "dashboard_001"
TOPICS     = [
    ("home/sensors/#", 1),       # telemetri
    ("devices/+/status", 1),   # cihaz durumu
]

stats = {"received": 0, "errors": 0}

def on_connect(client, userdata, flags, reason_code, properties):
    if reason_code == 0:
        client.subscribe(TOPICS)
        print(f"[dash] Bağlandı → {BROKER}:{PORT}")
        print(f"[dash] Dinlenen topic'ler: {[t for t, _ in TOPICS]}")
        print("-" * 60)
    else:
        print(f"[dash] Hata: {reason_code}")

def on_message(client, userdata, msg):
    ts = time.strftime("%H:%M:%S")
    stats["received"] += 1

    if "status" in msg.topic:
        status = msg.payload.decode()
        icon = "🟢" if status == "online" else "🔴"
        print(f"[{ts}] {icon} {msg.topic}: {status}")
        return

    try:
        d = json.loads(msg.payload)
        print(
            f"[{ts}] #{d.get('seq', '?'):04}  "
            f"🌡 {d['temperature']:6.2f}°C  "
            f"💧 {d['humidity']:5.1f}%  "
            f"🔵 {d['pressure']:8.2f} hPa"
        )
    except (json.JSONDecodeError, KeyError) as e:
        stats["errors"] += 1
        print(f"[{ts}] PARSE HATASI ({e}): {msg.payload[:80]}")

def on_disconnect(client, userdata, flags, reason_code, properties):
    print(f"\n[dash] Bağlantı kesildi (kod={reason_code})")
    print(f"[dash] Toplam: {stats['received']} mesaj, {stats['errors']} hata")

client = mqtt.Client(
    callback_api_version=mqtt.CallbackAPIVersion.VERSION2,
    client_id=CLIENT_ID
)
client.on_connect    = on_connect
client.on_message    = on_message
client.on_disconnect = on_disconnect

client.connect(BROKER, PORT, keepalive=60)
try:
    client.loop_forever()
except KeyboardInterrupt:
    print("\n[dash] Ctrl+C ile durduruldu.")

[dash] Bağlandı → localhost:1883
[dash] Dinlenen topic'ler: ['home/sensors/#', 'devices/+/status']
------------------------------------------------------------
[09:14:01] 🟢 devices/sensor_sim_001/status: online
[09:14:02] #0001  🌡  21.34°C  💧  58.3%  🔵  1014.83 hPa
[09:14:07] #0002  🌡  19.87°C  💧  52.1%  🔵  1012.44 hPa
[09:14:12] #0003  🌡  22.10°C  💧  60.7%  🔵  1015.21 hPa
[09:14:17] 🔴 devices/sensor_sim_001/status: offline