# Paho MQTT test
###### tags: `programming` `python` `C`

## Docker Compose

version: '3'

services:
  mosquitto:
    image: eclipse-mosquitto:latest
    ports:
      - 1883:1883
    volumes:
      - "./.mosquitto/config/mosquitto.conf:/mosquitto/config/mosquitto.conf"
      - "./.mosquitto/log:/mosquitto/log"
  server:
    image: rust:latest
    restart: always
    tty: true
    volumes:
      - "./mqtt-server:/root/mqtt-server"
  python-app:
    image: python:latest
    restart: always
    tty: true
    volumes:
      - "./python-app:/root/app"
  c-app:
    image: gcc:latest
    restart: always
    tty: true
    volumes:
      - "./c-app:/root/app"

## Paho MQTT Python

import paho.mqtt.client as mqtt
from time import sleep

# ブローカーに接続できたときの処理
def on_connect(client, userdata, flag, rc):
    print("Connected with result code " + str(rc))

# ブローカーが切断したときの処理
def on_disconnect(client, userdata, flag, rc):
    if rc != 0:
        print("Unexpected disconnection.")

# publishが完了したときの処理
def on_publish(client, userdata, mid):
    print("publish: {0}".format(mid))

# メイン関数
def main():
    # クラスのインスタンス(実体)の作成
    client = mqtt.Client()
    # 接続時のコールバック関数を登録
    client.on_connect = on_connect
    # 切断時のコールバックを登録
    client.on_disconnect = on_disconnect
    # メッセージ送信時のコールバック
    client.on_publish = on_publish
    # 接続先
    client.connect("localhost", 1883, 60)
    # 通信処理スタート
    client.loop_start()
    sleep(1)
    # 10回繰り返す
    for _ in range(3):
        # トピック名とメッセージを決めて送信
        mid = client.publish("/farms/uranum", "Hello World!")
        print(f"result : {mid}")
        sleep(3)
    # 後処理
    client.loop_stop()

if __name__ == "__main__":
    main()

## Paho MQTT C

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include "MQTTClient.h"

struct mqtt_client_t {
    MQTTClient handle;
    uint8_t qos;
    uint32_t timeout;
};

struct mqtt_client_t* initialize(const char* address, const char* id) {
    struct mqtt_client_t* client = (struct mqtt_client_t*)calloc(1, sizeof(struct mqtt_client_t));
    client->qos = 1;
    client->timeout = 10000L;
    MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
    int rc;
    if ((rc = MQTTClient_create(&client->handle, address, id,
        MQTTCLIENT_PERSISTENCE_NONE, NULL)) != MQTTCLIENT_SUCCESS) {
        printf("Failed to create client, return code %d\n", rc);
        exit(EXIT_FAILURE);
    }
    conn_opts.keepAliveInterval = 20;
    conn_opts.cleansession = 1;
    if ((rc = MQTTClient_connect(client->handle, &conn_opts)) != MQTTCLIENT_SUCCESS) {
        printf("Failed to connect, return code %d\n", rc);
        exit(EXIT_FAILURE);
    }
    return client;
}

void finalize(struct mqtt_client_t* client) {
    int rc;
    if ((rc = MQTTClient_disconnect(client->handle, 10000)) != MQTTCLIENT_SUCCESS) {
        printf("Failed to disconnect, return code %d\n", rc);
    }
    MQTTClient_destroy(&client->handle);
}

void publish(struct mqtt_client_t* client, const char* topic, const char* message) {
    MQTTResponse res;
    MQTTClient_message pubmsg = MQTTClient_message_initializer;
    MQTTClient_deliveryToken token;
    int rc;
    pubmsg.payload = (void*)message;
    pubmsg.payloadlen = (int)strlen(message);
    pubmsg.qos = client->qos;
    pubmsg.retained = 0;
    if ((rc = MQTTClient_publishMessage(client, topic, &pubmsg, &token)) != MQTTCLIENT_SUCCESS) {
        printf("Failed to publish message, return code %d\n", rc);
        exit(EXIT_FAILURE);
    }
    rc = MQTTClient_waitForCompletion(client, token, client->timeout);
}

int main(int argc, char* argv[])
{
    struct mqtt_client_t* client = initialize("tcp://mosquitto:1883", "uranum");;
    client->qos = 1;
    client->timeout = 10000;
    publish(client, "/farms/uranum", "Hello World!");
    finalize(client);
    return 0;
}

## Reference
[Eclipse](https://www.eclipse.org/paho/files/mqttdoc/MQTTClient/html/pubsync.html)