Monitor_Server/run_monitor.py

import os
import re
from time import sleep
from datetime import datetime
import time
import requests
import json
import schedule
from paho.mqtt import client as mqtt_client
import random

broker = 'broker.beetai.com'
port = 21883
topic = "v1/servers/server_test/telemetry"
client_id = f'python-mqtt-{random.randint(0, 1000)}'
name_server = 'Server Richy'
service = 'docker'
now = datetime.now()
def connect_mqtt():
    def on_connect(client, userdata, flags, rc):
        if rc == 0:
            print("Connected to MQTT Broker!")
        else:
            print("Failed to connect, return code %d\n", rc)

    client = mqtt_client.Client(client_id)
    # client.username_pw_set(username, password)
    client.on_connect = on_connect
    client.connect(broker, port)
    return client

def publish(client):
    while True:
        memory, memory_usage, swap_usage = get_memory()
        cpu_usage = get_cpu()
        mac_address = get_mac_address()
        boot_storage, boot_storage_usage = get_disk()
        storage, storage_usage = get_storage()
        ip_private, ip_public = get_IP()
        uptime = get_uptime()
        service_state = monitor_docker()
        time.sleep(5)
        params = {
            "server_id": "server_test",
            "mac_address": mac_address[0],
            "cpu_usage": str(cpu_usage),
            "memory": str(round(memory/1024/1024, 1 )),
            "memory_usage": str(memory_usage),
            "boot_storage": boot_storage[0],
            "boot_storage_usage": boot_storage_usage,
            "storage": storage[0],
            "storage_usage": storage_usage,
            "ip_private": ip_private[0],
            "ip_public": ip_public[0],
            "service_state": service_state,
            "temperature": "",
            "up_time": str(uptime)
        }
        json_params = json.dumps(params)
        print("json_params: ", json_params)
        msg = json.dumps(params)
        result = client.publish(topic, msg)
        # result: [0, 1]
        status = result[0]
        if status == 0:
            print(f"Send `{msg}` to topic `{topic}`")
        else:
            print(f"Failed to send message to topic {topic}")

def run():
    client = connect_mqtt()
    client.loop_start()
    publish(client)

def get_mac_address():
    mac_address = os.popen('cat /sys/class/net/enp2s0/address').read().split('\n')
    return mac_address

def get_IP():
    ip_private = os.popen('hostname -I').read().split(" ")
    ip_public = os.popen('wget -qO- http://ipecho.net/plain | xargs echo').read().split('\n')
    return ip_private, ip_public

def get_uptime():
    output = os.popen('uptime').read().split(" ")
    # print("output: ", output)
    _uptime = output[3]
    # print("_uptime:", _uptime)
    uptime_unit = output[4].split(",")
    if uptime_unit[0] == 'days':
        uptime = int(_uptime) * 24
        # print(uptime)
    else:
        return uptime
    return uptime

def check_stt_service():
    status = os.popen('sudo service' + ' ' + service + ' ' + 'status | grep running | wc -l')
    stt = status.read()
    return stt

def monitor_docker():
    lines = readfile()
    status_service = check_stt_service().split("\n")[0]
    print('Service docker status = ' + status_service)
    service_state=[]
    if status_service == '1':
        for line in lines:
            print(line.strip())
            l = line.strip().split('_')
            lts = ''.join([str(e) for e in l])
            try:
                o = os.popen('sudo docker inspect' + ' ' + line.strip())
                data = json.loads(o.read())
                try:
                    stt = data[0]['State']['Health']['Status']
                    if stt == 'healthy':
                        print('docker inspect service ' + line.strip() + ' = ' + stt)
                        pass
                    else:
                        print('docker inspect service ' + line.strip() + ' = ' + stt)
                        service_state.append(line.strip() + ':' + stt)
                except:
                    stt = data[0]['State']['Status']
                    if stt == 'running':
                        print(stt)
                        pass
                    else:
                        print('docker inspect service ' + line.strip() + ' = ' + stt)
                        service_state.append(line.strip() + ':' + stt)
            except:
                print('Do not inspect service ' + line.strip())
                service_state.append(line.strip() + ':' + stt)
    else:
        print(status_service)
    # print(', '.join(service_state))
    return ', '.join(service_state)

def get_memory():
    cmd = 'cat /proc/meminfo'
    i = os.popen(cmd).read()
    mem = i.split()
    memTotal = float(mem[1])
    memAvailable = float(mem[7])
    memUsed = round((memTotal - memAvailable) * 100 / memTotal)
    swapTotal = float(mem[43])
    swapFree = float(mem[46])
    swapUsed = round((swapTotal-swapFree) * 100 /swapTotal)
    return memTotal ,memUsed, swapUsed

def get_cpu():
    t = time.localtime()
    dtime = (str(t.tm_hour) + ':' + str(t.tm_min) + ':' + str(t.tm_sec) + ' ' + str(t.tm_mday) + '/' + str(t.tm_mon) + '/' + str(t.tm_year))
    cmd = 'grep "cpu " /proc/stat'
    output = os.popen(cmd)
    cpu = output.read().strip().split(' ')
    user = float(cpu[2])
    system = float(cpu[4])
    idle = float(cpu[5])
    cpu_used = round((user + system)*100 / (user + system + idle), 1)
    return cpu_used

def get_disk():
    cmd = 'df -h | grep /dev/sda5'
    output = os.popen(cmd).read().split(" ")
    # print("output: ", output)
    d_used = output[13].split("%")
    # print("d_used: ", d_used)
    boot_storage = output[7].split("G")
    boot_storage_usage = d_used[0]
    return boot_storage, boot_storage_usage

def get_storage():
    cmd = 'df -h | grep /dev/sda5'
    output = os.popen(cmd).read().split(" ")
    d_used = output[13].split("%")
    storage = output[7].split("G")
    storage_usage = d_used[0]
    return storage, storage_usage

def readfile():
    try:
        file = open('hosts.txt', 'r')
        Lines = file.readlines()
        return Lines
    finally:
        file.close()

if __name__ == '__main__':
    run()