updoot readme v1.2

Key Improvements:

Error Handling:
Used try-except blocks to catch errors from subprocesses and file operations, logging issues.

Thread Safety:
Introduced queue.Queue for thread-safe operations when handling ping results.

Subprocess Optimizations:
Used subprocess.run() for cleaner, more modern handling of subprocesses.
Avoided shell=True for security reasons unless absolutely necessary.

Service Management:
Improved service status checking by using systemctl is-active and using exit statuses for reliability.

User Authorization:
Checked user authorization in relevant commands like /restart, /reboot, and /ping.

Logging:
Introduced logging for all major operations to track activity and errors.

Polling Timeout:
Added timeouts and error handling to prevent the bot from hanging during long polling.

This updoot is bring more security, robustness, and scalability, ready to handle various edge cases that might occur in our system monitoring.

Signed-off-by: hax <hax@lainlounge.xyz>

.authorized_users

@@ -0,0 +1,2 @@
+AUTHORIZED_USER_ID_1
+AUTHORIZED_USER_ID_2

.env

@@ -0,0 +1 @@
+YOUR_TOKEN_HERE

.gitignore

@@ -0,0 +1,2 @@
+test.py
+venv/

README.md

@@ -1,54 +1,71 @@
-# LainMonitor
+# lainmonitor
 
-LainMonitor is a Telegram bot designed to monitor your system by providing real-time information about the system's status, services, and disk usage. It can also check connectivity to a specific Tailscale IP address.
+LainMonitor is a Telegram bot designed to monitor your system, providing real-time updates on the system’s status, essential services, and disk usage. It can also verify connectivity to a specific Tailscale IP address.
+Current version: v1.2
 
-## Features
+### Key Features:
-- Retrieve system hostname, uptime, and status of essential services such as:
-  - Zerotier
-  - Prosody
-  - PostgreSQL
-  - Tailscale
-- Check disk usage
-- Ping a Tailscale IP to verify connectivity
-- Use via Telegram commands like `/status`, `/ping`, and `/help`
 
-## Dependencies
+    Retrieve system information:
-- [Telebot](https://github.com/eternnoir/pyTelegramBotAPI) - A Python library for Telegram bot API.
+        Hostname
+        Uptime
+        Status of critical services:
+            Zerotier
+            Prosody
+            PostgreSQL
+            Tailscale
+            nginx
+    Check disk usage
+    Ping a Tailscale IP for connectivity verification
+    Restart critical services
+    Reboot the host
+    Accessible via Telegram commands
+
+### Prerequisites:
+
+    Python 3
+    Telebot — Python library for interacting with the Telegram bot API.
+
+### Installation Guide:
+
+Clone the repository:
 
-## Installation
-1. Clone this repository:
-    ```bash
     git clone https://git.lainlounge.xyz/hornet/lainmonitor.git
     cd lainmonitor
-    ```
-2. Install the required Python library:
-    ```bash
-    pip install pyTelegramBotAPI
-    ```
-3. Replace the placeholder in the code with your Telegram bot token:
-    ```python
-    TOKEN = 'PLACE_YOUR_TOKEN_HERE'
-    ```
 
-4. Set up permissions for the bot to check system services (run as a user with `sudo` access).
+RECOMMENDED: Create a virtual environment for python with:
+```
+python3 -m venv venv
+source venv/bin/activate
+```
+Install dependencies:
 
-## Usage
+```
-
+   pip3 install -r requirements.txt
-### Running Directly
-You can run the bot directly using Python:
-
-```bash
-python3 lainmonitor.py
 ```
 
-### Running as a Service
+Configure your bot token: Open the .env file and replace the placeholder with your Telegram bot token.
-To run LainMonitor as a service, follow these steps:
+
-1. Create a systemd service file:
+Configure authorized users: Open the .authorized_users file and replace the placeholders with Telegram user ID(s).
-    ```bash
+
+Set up service access: Ensure the bot can check system services by running it with sudo or appropriate permissions.
+
+### Usage:
+#### Running the Bot Manually:
+
+You can run LainMonitor directly from the command line:
+
+    python3 lainmonitor.py
+
+#### Running as a Systemd Service:
+
+To run the bot as a systemd service, follow these steps:
+
+Create a service file:
+
     sudo nano /etc/systemd/system/lainmonitor.service
-    ```
+
-2. Add the following configuration:
+Add the following configuration:
-    ```ini
+
     [Unit]
     Description=LainMonitor Telegram Bot
     After=network.target
@@ -59,21 +76,24 @@ To run LainMonitor as a service, follow these steps:
 
     [Install]
     WantedBy=multi-user.target
-    ```
+
-3. Enable and start the service:
+Enable and start the service:
-    ```bash
+
     sudo systemctl enable lainmonitor
     sudo systemctl start lainmonitor
-    ```
 
-## Telegram Bot Commands
+### Available Commands:
-- `/start`: Initialize the bot and receive a welcome message.
-- `/help`: Display available commands.
-- `/status`: Get the system hostname, status, uptime, and the status of monitored services.
-- `/ping`: Ping a Tailscale IP and return the connectivity status.
-- `/reboot`: (Work in progress) Placeholder for a reboot command.
 
-## Author
+    /start — Initialize the bot and receive a welcome message.
-Created by **hornetmaidan**
+    /help — Display a list of available commands.
+    /status — Retrieve system hostname, uptime, and status of monitored services.
+    /ping — Ping a Tailscale IP and return connectivity status.
+    /restart hostname- Restart a specific service on a specified machine.
+    /reboot hostname —  Placeholder for a system reboot command.
 
-Feel free to contribute or suggest features!
+### Contributions:
+
+Created by hornetmaidan. 
+With Contributions from h@x. 
+
+Any new features and suggestions are welcome!

lainmonitor.py

@@ -1,75 +1,197 @@
-#description: telegram bot for monitoring the system
+# --/usr/bin/env python3 -- #
-#dependencies: telebot
+# description: telegram bot for monitoring the system
-#usage: python3 lainmonitor.py | or run it as a service
+# dependencies: telebot
-#author: hornetmaidan
+# usage: python3 lainmonitor.py | or run it as a service
+# author: hornetmaidan
+# contributors: h@x
+# version: 1.2
+import os
 import subprocess
+import threading
+import queue
+from time import sleep
 import telebot
-#define the variables
+import logging
-status, hostname, uptime, zerotier, prosody, postgres, tailscale, disk, ping = 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown', 'unknown'
-#telegram bot token
-TOKEN = 'PLACE_YOUR_TOKEN_HERE'
 
-#bot init
+# Setup logging
-bot = telebot.TeleBot(TOKEN)
+logging.basicConfig(filename='lainmonitor.log', level=logging.INFO, 
+                    format='%(asctime)s - %(levelname)s - %(message)s')
 
-#get system info
+# Load environment variables and config files securely
-def getinfo():
+script_dir = os.path.dirname(os.path.realpath(__file__))
-    global status, hostname, uptime, zerotier, prosody, postgres, tailscale, disk
+env_path = os.path.join(script_dir, '.env')
-    hostname = subprocess.check_output(['hostname']).decode().strip()
+auth_users_path = os.path.join(script_dir, '.authorized_users')
-    uptime = subprocess.check_output(['uptime', '-p']).decode().strip()
+
-    #systemd-only services
+# Load the token
-    zerotier = subprocess.Popen("sudo systemctl status zerotier-one | grep 'Active'", shell=True, stdout=subprocess.PIPE).stdout.read().decode().strip()
+try:
-    prosody = subprocess.Popen("sudo systemctl status prosody | grep 'Active'", shell=True, stdout=subprocess.PIPE).stdout.read().decode().strip()
+    with open(env_path, 'r') as f:
-    postgres = subprocess.Popen("sudo systemctl status postgresql | grep 'Active'", shell=True, stdout=subprocess.PIPE).stdout.read().decode().strip()
+        token = f.read().strip()
-    tailscale = subprocess.Popen("sudo systemctl status tailscaled | grep 'Active'", shell=True, stdout=subprocess.PIPE).stdout.read().decode().strip()
+except FileNotFoundError:
-    disk = subprocess.check_output(['df', '-h']).decode().strip()
+    logging.error('Token file not found. Exiting...')
-    if hostname == 'unknown':
+    exit(1)
+
+# Load the authorized users
+try:
+    authorized_users = [str(line.strip()) for line in open(auth_users_path, 'r').readlines()]
+except FileNotFoundError:
+    logging.error('Authorized users file not found. Exiting...')
+    exit(1)
+
+# Initialize the bot
+bot = telebot.TeleBot(token)
+
+# Define status variables
+status, hostname, uptime = 'unknown', 'unknown', 'unknown'
+zerotier, prosody, postgres, tailscale, nginx, disk = ['unknown'] * 6
+nodes, hostnames, threads = [], [], []
+reach_queue = queue.Queue()
+
+# Get basic system info
+def get_system_info():
+    global hostname, uptime, zerotier, prosody, postgres, tailscale, nginx, disk
+    try:
+        hostname = subprocess.check_output(['hostname']).decode().strip()
+        uptime = subprocess.check_output(['uptime', '-p']).decode().strip()
+
+        services = ['zerotier-one', 'prosody', 'postgresql', 'tailscaled', 'nginx']
+        status_results = []
+        for service in services:
+            status_results.append(get_service_status(service))
+        zerotier, prosody, postgres, tailscale, nginx = status_results
+
+        disk = subprocess.check_output(['df', '-h']).decode().strip()
+    except subprocess.CalledProcessError as e:
+        logging.error(f"Error fetching system info: {e}")
         status = 'offline'
     else:
         status = 'online'
-    return hostname, uptime, zerotier, prosody, postgres, tailscale, disk
 
-#ping tailscale (change the IP address to the one you want or add more)
+# Helper function to get service status
-def check_tailscale():
+def get_service_status(service):
-    global ping
+    try:
-    ping = subprocess.Popen("ping TAILSCALE_IP -c 1 | grep '1 packets'", shell=True, stdout=subprocess.PIPE).stdout.read().decode().strip()
+        subprocess.run(['sudo', 'systemctl', 'is-active', '--quiet', service], check=True)
-    if '1 received' in ping:
+        return f'{service} is active'
-        ping = 'connected'
+    except subprocess.CalledProcessError:
+        return f'{service} is inactive/not present'
+
+# Function to ping a Tailscale node
+def ping_node(node, hostname):
+    try:
+        ping = subprocess.run(['ping', '-c', '1', node], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)
+        reach_queue.put(f'{node}/{hostname} is reachable')
+    except subprocess.CalledProcessError:
+        reach_queue.put(f'{node}/{hostname} is unreachable')
+
+# Check Tailscale nodes
+def check_tailscale_nodes():
+    global nodes, hostnames, threads
+    try:
+        nodes_output = subprocess.check_output("tailscale status | grep '100'", shell=True).decode().strip()
+        nodes = [line.split()[0] for line in nodes_output.split('\n') if line]
+        hostnames = [line.split()[1] for line in nodes_output.split('\n') if line]
+
+        for node, hostname in zip(nodes, hostnames):
+            thread = threading.Thread(target=ping_node, args=(node, hostname))
+            threads.append(thread)
+            thread.start()
+
+        for thread in threads:
+            thread.join()
+
+        reach = []
+        while not reach_queue.empty():
+            reach.append(reach_queue.get())
+
+        return reach
+    except subprocess.CalledProcessError as e:
+        logging.error(f"Error checking Tailscale status: {e}")
+        return ['Error checking Tailscale status']
+
+# Function to restart a service
+def restart_service(service):
+    logging.info(f'Restarting {service}...')
+    try:
+        subprocess.run(['sudo', 'systemctl', 'restart', service], check=True)
+        sleep(3)
+        service_status = get_service_status(service)
+        status_message = f'{service} restarted! Status: {service_status}'
+        logging.info(status_message)
+        return status_message
+    except subprocess.CalledProcessError as e:
+        logging.error(f"Error restarting {service}: {e}")
+        return f'Error restarting {service}'
+
+# Restart services menu
+def restart_menu():
+    keyboard = [
+        [telebot.types.InlineKeyboardButton('zerotier-one', callback_data='zerotier-one')],
+        [telebot.types.InlineKeyboardButton('prosody', callback_data='prosody')],
+        [telebot.types.InlineKeyboardButton('postgresql', callback_data='postgresql')],
+        [telebot.types.InlineKeyboardButton('tailscaled', callback_data='tailscaled')],
+        [telebot.types.InlineKeyboardButton('nginx', callback_data='nginx')],
+        [telebot.types.InlineKeyboardButton('cancel', callback_data='cancel')]
+    ]
+    reply_markup = telebot.types.InlineKeyboardMarkup(keyboard)
+    return reply_markup
+
+# Callback query handler for service restart
+@bot.callback_query_handler(func=lambda call: True)
+def callback_query(call):
+    service = call.data
+    if service != 'cancel':
+        status_message = restart_service(service)
+        bot.send_message(call.message.chat.id, status_message)
     else:
-        ping = 'unreachable'
+        bot.edit_message_reply_markup(call.message.chat.id, call.message.message_id, reply_markup=None)
-    return ping
+        bot.send_message(call.message.chat.id, 'Canceled')
 
-#debug handler
+# Reboot system function
-def check():
+def reboot():
-    global status, hostname, uptime, zerotier, prosody, postgres, tailscale, disk
+    logging.info('Rebooting system...')
-    getinfo()
+    subprocess.run(['sudo', 'reboot'], check=True)
-    print('system status:', status)
-    print('hostname:', hostname)
-    print('uptime:', uptime)
-    print('zerotier:', zerotier)
-    print('prosody:', prosody)
-    print('postgres:', postgres)
-    print('tailscale:', tailscale)
-    print('disk:', disk)
-    return status, hostname, uptime, zerotier, prosody, postgres, tailscale, disk
 
-#message handling
+# Populate teh variables on first start
-@bot.message_handler(commands=['start', 'help', 'status', 'reboot', 'ping'])
+get_system_info()
+
+# Message handlers
+@bot.message_handler(commands=['start', 'help', 'status', 'restart', 'reboot', 'ping'])
 def handle(message):
-    if message.text == '/start':
+    user_id = str(message.from_user.id)
-        bot.reply_to(message, 'lainmonitor v1.0 --- standing by...')
+    if user_id not in authorized_users:
-    elif message.text == '/help':
+        bot.reply_to(message, 'You are not authorized for this action')
-        bot.reply_to(message, 'commands: /start, /help, /status, /reboot, /ping')
+    else:
-    elif message.text == '/status':
+        if message.text == '/start':
-        check()
+            bot.reply_to(message, 'lainmonitor v1.2 --- standing by...')
-        status_message = f'hostname: {hostname}\nsystem status: {status}\nuptime: {uptime}\nzerotier: {zerotier}\nprosody: {prosody}\npostgres: {postgres}\ntailscale: {tailscale}'
+        elif message.text == '/help':
-        bot.reply_to(message, status_message)
+            bot.reply_to(message, 'commands: /start, /help, /status, /restart, /reboot, /ping')
-        bot.reply_to(message, f'filesystem info for {hostname}: \n\n{disk}')
+            bot.reply_to(message, 'commands: /start, /help, /status, /restart, /reboot, /ping')
-    elif message.text == '/reboot':
+        elif message.text == '/status':
-        bot.reply_to(message, 'work in progress...')
+            get_system_info()
-    elif message.text == '/ping':
+            status_message = (
-        check_tailscale()
+                f'hostname: {hostname}\n'
-        bot.reply_to(message, f'ping status: {ping}')
+                f'system status: {status}\n'
+                f'uptime: {uptime}\n'
+                f'zerotier: {zerotier}\n'
+                f'prosody: {prosody}\n'
+                f'postgres: {postgres}\n'
+                f'tailscale: {tailscale}\n'
+                f'nginx: {nginx}'
+            )
+            bot.reply_to(message, status_message)
+            bot.reply_to(message, f'Filesystem info for {hostname}:\n\n{disk}')
+        elif message.text == f'/restart {hostname}':
+            bot.send_message(message.chat.id, 'Select a service to restart:', reply_markup=restart_menu())
+        elif message.text == f'/reboot {hostname}':
+            bot.reply_to(message, f'Rebooting {hostname}...')
+            reboot()
+        elif message.text == '/ping':
+            reach = check_tailscale_nodes()
+            bot.reply_to(message, f'Ping status:\n\n{"\n".join(reach)}')
+        else:
+            pass
+# Polling with timeout and error handling
+try:
+    bot.polling(none_stop=True, timeout=60, long_polling_timeout=60)
+except Exception as e:
+    logging.error(f'Polling error: {e}')
 
-#polling
-bot.polling()