OLT-zte send_telegram - Pastebin.com

import re

import os

import requests

import time

from datetime import datetime, date

from collections import defaultdict

import configparser

import logging

import schedule

import threading

import sys

# Налаштування логів

LOG_FILE_PATH = '/opt/olt_monitor/olt_monitor.log'

LAN_EVENTS_LOG = '/opt/olt_monitor/lan_events.log' # Новий лог для подій

SENT_MESSAGES_FILE = '/opt/olt_monitor/sent_messages.txt'

LAST_RESET_FILE = '/opt/olt_monitor/last_log_reset.txt'

LAST_ACTIVATION_FILE = '/opt/olt_monitor/last_activation.txt'

# Створення lan_events.log при старті, якщо не існує

if not os.path.exists(LAN_EVENTS_LOG):

try:

with open(LAN_EVENTS_LOG, 'w', encoding='utf-8') as f:

f.write('')

logging.info(f"Створено файл {LAN_EVENTS_LOG}")

except Exception as e:

logging.error(f"Помилка створення {LAN_EVENTS_LOG}: {e}")

raise

# Налаштування логгера для lan_events.log

lan_logger = logging.getLogger('lan_events')

lan_handler = logging.FileHandler(LAN_EVENTS_LOG, encoding='utf-8')

lan_handler.setFormatter(logging.Formatter('%(asctime)s [%(levelname)s] %(message)s'))

lan_logger.addHandler(lan_handler)

lan_logger.setLevel(logging.INFO)

# Змінна для відстеження часу попереджень

last_size_warning = {}

# Налаштування логування в консоль і olt_monitor.log

logging.basicConfig(

level=logging.INFO,

format='%(asctime)s [%(levelname)s] %(message)s',

handlers=[logging.StreamHandler(), logging.FileHandler(LOG_FILE_PATH, encoding='utf-8')]

)

# Завантаження конфігурації

config = configparser.ConfigParser()

try:

config.read('/opt/olt_monitor/config.ini')

except Exception as e:

logging.error(f"Помилка читання config.ini: {e}")

raise

# Конфігурація

try:

TELEGRAM_BOT_TOKEN = config.get('Settings', 'TelegramBotToken')

TELEGRAM_CHAT_IDS = config.get('Settings', 'TelegramChatIDs').split(',')

REPORT_TIME = config.get('Settings', 'ReportTime', fallback='06:00')

LOG_FILE = config.get('Settings', 'LogFile', fallback='/var/log/zte.log')

LAST_POSITION_FILE = config.get('Settings', 'LastPositionFile', fallback='/opt/olt_monitor/last_position.txt')

CHECK_INTERVAL = config.getint('Settings', 'CheckInterval', fallback=5)

except Exception as e:

logging.error(f"Помилка парсингу конфігурації: {e}")

raise

# Завантажуємо відправлені повідомлення

def load_sent_messages():

if not os.path.exists(SENT_MESSAGES_FILE):

return set()

try:

with open(SENT_MESSAGES_FILE, 'r', encoding='utf-8') as f:

return set(line.strip() for line in f if line.strip())

except Exception as e:

logging.error(f"Помилка читання файлу {SENT_MESSAGES_FILE}: {e}")

return set()

# Зберігаємо нове повідомлення

def save_sent_message(msg, sent_messages):

try:

with open(SENT_MESSAGES_FILE, 'a', encoding='utf-8') as f:

f.write(msg + '\n')

sent_messages.add(msg)

except Exception as e:

logging.error(f"Помилка збереження повідомлення в {SENT_MESSAGES_FILE}: {e}")

# Перевірка часу останнього повідомлення про активацію

def can_send_activation():

if not os.path.exists(LAST_ACTIVATION_FILE):

return True

try:

with open(LAST_ACTIVATION_FILE, 'r') as f:

last_time = float(f.read().strip())

return (time.time() - last_time) > 300 # 5 хвилин

except Exception as e:

logging.error(f"Помилка читання {LAST_ACTIVATION_FILE}: {e}")

return True

# Зберігаємо час активації

def save_activation_time():

try:

with open(LAST_ACTIVATION_FILE, 'w') as f:

f.write(str(time.time()))

except Exception as e:

logging.error(f"Помилка збереження {LAST_ACTIVATION_FILE}: {e}")

# Відправка повідомлення в Telegram

def send_telegram(msg, sent_messages):

if msg in sent_messages:

logging.warning(f"Повідомлення вже відправлено, пропущено: {msg}")

return

url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage"

for chat_id in TELEGRAM_CHAT_IDS:

try:

response = requests.post(url, data={"chat_id": chat_id.strip(), "text": msg}, timeout=10)

response.raise_for_status()

logging.info(f"Повідомлення успішно відправлено в Telegram (chat_id: {chat_id}): {msg}")

save_sent_message(msg, sent_messages)

except requests.RequestException as e:

error_msg = f"Помилка відправки в Telegram для chat_id {chat_id}: {e}, response: {response.text if 'response' in locals() else 'немає відповіді'}"

logging.error(error_msg)

critical_msg = f"⚠️ Критична помилка в olt_monitor.py:\n{error_msg}"

if critical_msg not in sent_messages:

try:

for critical_chat_id in TELEGRAM_CHAT_IDS:

requests.post(url, data={"chat_id": critical_chat_id.strip(), "text": critical_msg}, timeout=10)

save_sent_message(critical_msg, sent_messages)

except Exception as critical_e:

logging.error(f"Не вдалося відправити критичну помилку в Telegram: {critical_e}")

# Відправка довгих повідомлень з розбиттям

def send_long_telegram(msg, sent_messages, max_length=4000):

if len(msg) <= max_length:

send_telegram(msg, sent_messages)

return

logging.info(f"Повідомлення перевищує {max_length} символів (довжина: {len(msg)}), розбиття на частини")

parts = []

current_part = f"📊 Звіт подій LAN за {date.today()}:\n\n"

entry_lines = []

lines = msg.split('\n')

# Пропускаем шапку и собираем записи

for line in lines[2:]: # Пропускаем первые две строки (шапка)

if line.strip() == "": # Конец записи (пустая строка)

if entry_lines:

entry_text = '\n'.join(entry_lines) + '\n\n'

if len(current_part) + len(entry_text) > max_length:

parts.append(current_part.strip())

current_part = f"📊 Звіт подій LAN за {date.today()} (продовження):\n\n"

current_part += entry_text

entry_lines = []

else:

entry_lines.append(line)

# Добавляем последнюю запись

if entry_lines:

entry_text = '\n'.join(entry_lines) + '\n\n'

if len(current_part) + len(entry_text) > max_length:

parts.append(current_part.strip())

current_part = f"📊 Звіт подій LAN за {date.today()} (продовження):\n\n"

current_part += entry_text

# Добавляем текущую часть, если она не пуста

if current_part.strip() != f"📊 Звіт подій LAN за {date.today()} (продовження):":

parts.append(current_part.strip())

# Отправляем части

for i, part in enumerate(parts, 1):

send_telegram(part, sent_messages)

logging.info(f"Відправлено частину {i} звіту (довжина: {len(part)} символів)")

# Відправка звіту про події LAN у Telegram (з очищенням lan_events.log)

def send_lan_summary_to_telegram(sent_messages):

logging.info("Початок створення звіту про події LAN")

summary = defaultdict(lambda: {'los': 0, 'restore': 0})

today = str(date.today())

try:

if not os.path.exists(LAN_EVENTS_LOG):

logging.info(f"Файл {LAN_EVENTS_LOG} не існує")

else:

with open(LAN_EVENTS_LOG, 'r', encoding='utf-8') as f:

lines_processed = 0

current_entry = []

for line in f:

line = line.strip()

if not line:

continue

# Начало новой записи определяется по временной метке (YYYY-MM-DD HH:MM:SS, с опциональными миллисекундами)

if re.match(r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:,\d+)?", line):

if current_entry: # Обрабатываем предыдущую запись

lines_processed += 1

entry_text = '\n'.join(current_entry)

logging.debug(f"Обробка запису у {LAN_EVENTS_LOG}: {entry_text}")

# Извлекаем порт, OLT и номер ONU

port_match = re.search(r"Порт: (gpon-onu_\d+/\d+/\d+(?::\d+)?)", entry_text)

olt_match = re.search(r"OLT: (\S+) \((\d+\.\d+\.\d+\.\d+)\)", entry_text)

onu_match = re.search(r"ONU №(\d+)", entry_text)

if port_match and olt_match and onu_match:

port = port_match.group(1)

olt_name = olt_match.group(1)

olt_ip = olt_match.group(2)

onu_number = onu_match.group(1)

key = (port, olt_name, olt_ip, onu_number)

if "LAN LOS знайдено" in entry_text:

summary[key]['los'] += 1

logging.debug(f"Знайдено LAN LOS для {key} у {LAN_EVENTS_LOG}")

elif "LAN LOS Restore знайдено" in entry_text:

summary[key]['restore'] += 1

logging.debug(f"Знайдено LAN LOS Restore для {key} у {LAN_EVENTS_LOG}")

else:

logging.debug(f"Запис не відповідає формату port/olt/onu: {entry_text}")

current_entry = []

current_entry.append(line)

else:

current_entry.append(line)

# Обработка последней записи

if current_entry:

lines_processed += 1

entry_text = '\n'.join(current_entry)

logging.debug(f"Обробка останнього запису у {LAN_EVENTS_LOG}: {entry_text}")

port_match = re.search(r"Порт: (gpon-onu_\d+/\d+/\d+(?::\d+)?)", entry_text)

olt_match = re.search(r"OLT: (\S+) \((\d+\.\d+\.\d+\.\d+)\)", entry_text)

onu_match = re.search(r"ONU №(\d+)", entry_text)

if port_match and olt_match and onu_match:

port = port_match.group(1)

olt_name = olt_match.group(1)

olt_ip = olt_match.group(2)

onu_number = onu_match.group(1)

key = (port, olt_name, olt_ip, onu_number)

if "LAN LOS знайдено" in entry_text:

summary[key]['los'] += 1

logging.debug(f"Знайдено LAN LOS для {key} у {LAN_EVENTS_LOG}")

elif "LAN LOS Restore знайдено" in entry_text:

summary[key]['restore'] += 1

logging.debug(f"Знайдено LAN LOS Restore для {key} у {LAN_EVENTS_LOG}")

else:

logging.debug(f"Останній запис не відповідає формату: {entry_text}")

logging.info(f"Оброблено {lines_processed} записів у {LAN_EVENTS_LOG}")

# Формирование отчета

if summary:

msg = f"📊 Звіт подій LAN за {today}:\n\n"

for (port, olt_name, olt_ip, onu_number), counts in sorted(summary.items()):

total = counts['los'] + counts['restore']

msg += (

f"🔢 ONU №{onu_number}\n"

f"📍 Порт: {port}\n"

f"🖥 OLT: {olt_name} ({olt_ip})\n"

f"🔴 Втрата LAN: {counts['los']}\n"

f"🟢 LAN відновлено: {counts['restore']}\n"

f"🔢 Загалом: {total}\n\n"

)

else:

msg = f"📊 Звіт подій LAN за {today}:\n\n⚠️ Подій LAN LOS або Restore не знайдено"

send_long_telegram(msg.strip(), sent_messages)

logging.info("Звіт про події LAN відправлено в Telegram")

# Очищаем lan_events.log после отправки

try:

with open(LAN_EVENTS_LOG, 'w', encoding='utf-8') as f:

f.write('')

logging.info(f"Файл {LAN_EVENTS_LOG} очищено після відправки звіту")

except Exception as e:

logging.error(f"Помилка очищення {LAN_EVENTS_LOG}: {e}")

except Exception as e:

logging.error(f"Помилка створення звіту LAN: {e}")

# Ручна перевірка звіту без очищення lan_events.log

def manual_lan_summary():

sent_messages = load_sent_messages()

logging.info("Початок ручної перевірки звіту про події LAN")

summary = defaultdict(lambda: {'los': 0, 'restore': 0})

today = str(date.today())

try:

if not os.path.exists(LAN_EVENTS_LOG):

logging.info(f"Файл {LAN_EVENTS_LOG} не існує")

else:

with open(LAN_EVENTS_LOG, 'r', encoding='utf-8') as f:

lines_processed = 0

current_entry = []

for line in f:

line = line.strip()

if not line:

continue

# Начало новой записи определяется по временной метке

if re.match(r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:,\d+)?", line):

if current_entry: # Обрабатываем предыдущую запись

lines_processed += 1

entry_text = '\n'.join(current_entry)

logging.debug(f"Обробка запису у {LAN_EVENTS_LOG}: {entry_text}")

port_match = re.search(r"Порт: (gpon-onu_\d+/\d+/\d+(?::\d+)?)", entry_text)

olt_match = re.search(r"OLT: (\S+) \((\d+\.\d+\.\d+\.\d+)\)", entry_text)

onu_match = re.search(r"ONU №(\d+)", entry_text)

if port_match and olt_match and onu_match:

port = port_match.group(1)

olt_name = olt_match.group(1)

olt_ip = olt_match.group(2)

onu_number = onu_match.group(1)

key = (port, olt_name, olt_ip, onu_number)

if "LAN LOS знайдено" in entry_text:

summary[key]['los'] += 1

logging.debug(f"Знайдено LAN LOS для {key} у {LAN_EVENTS_LOG}")

elif "LAN LOS Restore знайдено" in entry_text:

summary[key]['restore'] += 1

logging.debug(f"Знайдено LAN LOS Restore для {key} у {LAN_EVENTS_LOG}")

else:

logging.debug(f"Запис не відповідає формату port/olt/onu: {entry_text}")

current_entry = []

current_entry.append(line)

else:

current_entry.append(line)

# Обработка последней записи

if current_entry:

lines_processed += 1

entry_text = '\n'.join(current_entry)

logging.debug(f"Обробка останнього запису у {LAN_EVENTS_LOG}: {entry_text}")

port_match = re.search(r"Порт: (gpon-onu_\d+/\d+/\d+(?::\d+)?)", entry_text)

olt_match = re.search(r"OLT: (\S+) \((\d+\.\d+\.\d+\.\d+)\)", entry_text)

onu_match = re.search(r"ONU №(\d+)", entry_text)

if port_match and olt_match and onu_match:

port = port_match.group(1)

olt_name = olt_match.group(1)

olt_ip = olt_match.group(2)

onu_number = onu_match.group(1)

key = (port, olt_name, olt_ip, onu_number)

if "LAN LOS знайдено" in entry_text:

summary[key]['los'] += 1

logging.debug(f"Знайдено LAN LOS для {key} у {LAN_EVENTS_LOG}")

elif "LAN LOS Restore знайдено" in entry_text:

summary[key]['restore'] += 1

logging.debug(f"Знайдено LAN LOS Restore для {key} у {LAN_EVENTS_LOG}")

else:

logging.debug(f"Останній запис не відповідає формату: {entry_text}")

logging.info(f"Оброблено {lines_processed} записів у {LAN_EVENTS_LOG}")

# Формирование отчета

if summary:

msg = f"📊 Ручний звіт подій LAN за {today}:\n\n"

for (port, olt_name, olt_ip, onu_number), counts in sorted(summary.items()):

total = counts['los'] + counts['restore']

msg += (

f"🔢 ONU №{onu_number}\n"

f"📍 Порт: {port}\n"

f"🖥 OLT: {olt_name} ({olt_ip})\n"

f"🔴 Втрата LAN: {counts['los']}\n"

f"🟢 LAN відновлено: {counts['restore']}\n"

f"🔢 Загалом: {total}\n\n"

)

else:

msg = f"📊 Ручний звіт подій LAN за {today}:\n\n⚠️ Подій LAN LOS або Restore не знайдено"

send_long_telegram(msg.strip(), sent_messages)

logging.info("Ручний звіт про події LAN відправлено в Telegram")

except Exception as e:

logging.error(f"Помилка створення ручного звіту LAN: {e}")

# Налаштування логування та перезапису файлів

def setup_logging_and_messages():

try:

logging.info("Початок налаштування логування")

last_reset_date = None

if os.path.exists(LAST_RESET_FILE):

with open(LAST_RESET_FILE, 'r') as f:

last_reset_date = f.read().strip()

logging.info(f"Прочитано дату останнього перезапису: {last_reset_date}")

else:

logging.info(f"Файл {LAST_RESET_FILE} не існує, буде створено")

today = str(date.today())

logging.info(f"Поточна дата: {today}")

# Перевірка розміру логу

log_size_mb = os.path.getsize(LOG_FILE_PATH) / (1024 * 1024) if os.path.exists(LOG_FILE_PATH) else 0

logging.info("Розмір логу: " + str(round(log_size_mb, 2)) + " МБ")

if last_reset_date != today:

sent_messages = load_sent_messages()

try:

logging.basicConfig(

filename=LOG_FILE_PATH,

level=logging.INFO,

format='%(asctime)s [%(levelname)s] %(message)s',

filemode='w',

force=True

)

logging.info(f"Лог перезаписано для нової доби (size={log_size_mb:.2f} МБ)")

with open(SENT_MESSAGES_FILE, 'w', encoding='utf-8') as f:

f.write('')

logging.info("Файл sent_messages.txt перезаписано для нової доби")

with open(LAST_RESET_FILE, 'w') as f:

f.write(today)

logging.info(f"Оновлено {LAST_RESET_FILE} з датою {today}")

except Exception as e:

logging.error(f"Помилка при перезаписі файлів: {e}")

raise

else:

logging.basicConfig(

filename=LOG_FILE_PATH,

level=logging.INFO,

format='%(asctime)s [%(levelname)s] %(message)s',

filemode='a',

force=True

)

logging.info("Дата не змінилася, використовується режим додавання")

except Exception as e:

logging.error(f"Критична помилка налаштування: {e}")

print(f"Критична помилка налаштування: {e}")

raise

# Перевірка розміру файлів

def check_file_size(file_path, file_name, max_size_mb=10):

try:

if os.path.exists(file_path):

size_mb = os.path.getsize(file_path) / (1024 * 1024)

if size_mb > max_size_mb:

current_time = time.time()

last_warning_time = last_size_warning.get(file_name, 0)

if current_time - last_warning_time > 600:

logging.warning(f"Розмір {file_name} перевищує {max_size_mb} МБ: {size_mb:.2f} МБ")

last_size_warning[file_name] = current_time

except Exception as e:

logging.error(f"Помилка перевірки розміру {file_name}: {e}")

# Глобальні змінні

current_interface = None

current_olt_name = None

current_olt_ip = None

current_description = None

onu_add_buffer = defaultdict(dict)

# Завантажуємо останню позицію

def load_last_position():

if not os.path.exists(LAST_POSITION_FILE):

return 0, os.stat(LOG_FILE).st_ino if os.path.exists(LOG_FILE) else 0

try:

with open(LAST_POSITION_FILE, 'r') as f:

pos = f.read().strip()

if pos == '':

return 0, os.stat(LOG_FILE).st_ino

return int(pos), os.stat(LOG_FILE).st_ino

except Exception as e:

logging.error(f"Помилка читання позиції з {LAST_POSITION_FILE}: {e}")

return 0, os.stat(LOG_FILE).st_ino if os.path.exists(LOG_FILE) else 0

# Зберігаємо останню позицію

def save_last_position(position):

try:

with open(LAST_POSITION_FILE, 'w') as f:

f.write(str(position))

except Exception as e:

logging.error(f"Помилка збереження позиції в {LAST_POSITION_FILE}: {e}")

# Парсинг логу

def parse_log(file_obj, start_pos, sent_messages):

global current_interface, current_olt_name, current_olt_ip, current_description

try:

file_obj.seek(start_pos)

file_size = os.path.getsize(LOG_FILE)

if start_pos > file_size:

logging.warning(f"start_pos ({start_pos}) більше file_size ({file_size}), скидаємо на 0")

start_pos = 0

file_obj.seek(0)

lines = file_obj.readlines()

end_pos = file_obj.tell()

except Exception as e:

logging.error(f"Помилка читання файлу логу: {e}")

return start_pos

for line in lines:

line = line.strip().replace('#012', '').replace('#015', '')

if not line:

continue

# Витягуємо ім'я та IP OLT

m_olt = re.search(r"\[(\S+) (\d+\.\d+\.\d+\.\d+)\]", line)

if m_olt:

current_olt_name = m_olt.group(1)

current_olt_ip = m_olt.group(2)

# Витягуємо час

time_match = re.match(r"^\w+\s+\d+\s+(\d{2}:\d{2}:\d{2})", line)

time_str = time_match.group(1) if time_match else datetime.now().strftime("%H:%M:%S")

try:

event_time = datetime.strptime(time_str, "%H:%M:%S")

event_time = event_time.replace(year=datetime.now().year, month=datetime.now().month, day=datetime.now().day)

except ValueError as e:

logging.error(f"Помилка формату часу {time_str}: {e}")

continue

# Перевіряємо OLT перед обробкою подій

if not current_olt_name or not current_olt_ip:

logging.warning(f"Пропущено подію через відсутність OLT: {line}")

continue

# Витягуємо інтерфейс

m_intf = re.search(r"(?:interface\s+)(gpon-olt_\d+/\d+/\d+|gpon-onu_\d+/\d+/\d+:\d+)", line, re.IGNORECASE)

if m_intf:

current_interface = m_intf.group(1)

continue

# Витягуємо description

m_desc = re.search(r"description\s+(\S+)", line, re.IGNORECASE)

if m_desc:

current_description = m_desc.group(1)

for key, data in list(onu_add_buffer.items()):

if key[2] == current_interface or key[2].replace("gpon-olt_", "gpon-onu_") + f":{key[3]}" == current_interface:

data['description'] = current_description

desc_str = f"\n🏷 Опис: {data['description']}" if data['description'] else ""

msg = (

f"✅ ONU додано\n\n"

f"🕒 Час: {data['time_str']}\n"

f"🔢 ONU №{data['onu_number']}\n"

f"📍 Порт: {data['onu_iface']}{desc_str}\n"

f"🖥 OLT: {key[0]} ({key[1]})"

)

send_telegram(msg, sent_messages)

del onu_add_buffer[key]

continue

# LAN LOS Alarm

m_lan_los = re.search(r"(?:GponRm notify:.*)?<gpon-onu_\d+/\d+/\d+:\d+>\s*SubType:\d+\s*Pos:\d+\s*ONU Uni lan los\. alarm", line, re.IGNORECASE)

if m_lan_los:

m_iface_num = re.search(r"<(gpon-onu_\d+/\d+/\d+):(\d+)>", line)

if m_iface_num:

onu_iface = m_iface_num.group(1)

onu_num = m_iface_num.group(2)

desc_str = f"\n🏷 Опис: {current_description}" if current_description and current_interface == onu_iface else ""

msg = (

f"🔴 Втрата LAN-з'єднання\n\n"

f"🕒 Час: {time_str}\n"

f"🔢 ONU №{onu_num}\n"

f"📍 Порт: {onu_iface}{desc_str}\n"

f"🖥 OLT: {current_olt_name} ({current_olt_ip})"

)

lan_logger.warning(f"LAN LOS знайдено: {msg}") # Записываем только в lan_events.log

current_description = None

continue

# LAN LOS Restore

m_lan_restore = re.search(r"(?:GponRm notify:.*)?<gpon-onu_\d+/\d+/\d+:\d+>\s*SubType:\d+\s*Pos:\d+\s*ONU Uni lan los\. restore", line, re.IGNORECASE)

if m_lan_restore:

m_iface_num = re.search(r"<(gpon-onu_\d+/\d+/\d+):(\d+)>", line)

if m_iface_num:

onu_iface = m_iface_num.group(1)

onu_num = m_iface_num.group(2)

desc_str = f"\n🏷 Опис: {current_description}" if current_description and current_interface == onu_iface else ""

msg = (

f"🟢 LAN-з'єднання відновлено\n\n"

f"🕒 Час: {time_str}\n"

f"🔢 ONU №{onu_num}\n"

f"📍 Порт: {onu_iface}{desc_str}\n"

f"🖥 OLT: {current_olt_name} ({current_olt_ip})"

)

lan_logger.warning(f"LAN LOS Restore знайдено: {msg}") # Записываем только в lan_events.log

current_description = None

continue

# Видалення ONU

m_no_onu = re.search(r"\b(?:no\s+onu|ont delete)\s+(\d+)(?:\s+\d+)?|ont delete\s+(\d+/\d+/\d+)\s+(\d+)", line, re.IGNORECASE)

if m_no_onu:

onu_iface = m_no_onu.group(2) or current_interface or "невідомий"

onu_number = m_no_onu.group(1) or m_no_onu.group(3)

desc_str = f"\n🏷 Опис: {current_description}" if current_description and current_interface == onu_iface else ""

msg = (

f"❌ ONU видалено\n\n"

f"🕒 Час: {time_str}\n"

f"🔢 ONU №{onu_number}\n"

f"📍 Порт: {onu_iface}{desc_str}\n"

f"🖥 OLT: {current_olt_name} ({current_olt_ip})"

)

send_telegram(msg, sent_messages)

current_description = None

key = (current_olt_name, current_olt_ip, onu_iface, onu_number)

if key in onu_add_buffer:

del onu_add_buffer[key]

continue

# Додавання ONU

m_add_onu = re.search(r"\b(?:onu\s+add|ont add)\s+(\d+)\s+(\d+)|ont add\s+(\d+/\d+/\d+)\s+(\d+)|onu\s+(\d+)\s+type\s+\S+\s+sn\s+\S+", line, re.IGNORECASE)

if m_add_onu:

onu_iface = m_add_onu.group(1) or m_add_onu.group(3) or current_interface or "невідомий"

onu_number = m_add_onu.group(2) or m_add_onu.group(4) or m_add_onu.group(5)

key = (current_olt_name, current_olt_ip, onu_iface, onu_number)

onu_add_buffer[key] = {

'time_str': time_str,

'onu_iface': onu_iface,

'onu_number': onu_number,

'description': current_description if current_interface == onu_iface else None,

'timestamp': datetime.now()

}

current_description = None

continue

# Обробка відкладених подій ONU

current_time = datetime.now()

for key, data in list(onu_add_buffer.items()):

if (current_time - data['timestamp']).seconds >= 5:

desc_str = f"\n🏷 Опис: {data['description']}" if data['description'] else ""

msg = (

f"✅ ONU додано\n\n"

f"🕒 Час: {data['time_str']}\n"

f"🔢 ONU №{data['onu_number']}\n"

f"📍 Порт: {data['onu_iface']}{desc_str}\n"

f"🖥 OLT: {key[0]} ({key[1]})"

)

send_telegram(msg, sent_messages)

del onu_add_buffer[key]

return end_pos

# Моніторинг логу

def monitor_log():

sent_messages = load_sent_messages()

if can_send_activation():

test_msg = f"🔔 Моніторинг OLT активовано\n\n🕒 Час: {datetime.now().strftime('%H:%M:%S')}"

send_telegram(test_msg, sent_messages)

save_activation_time()

last_pos, last_inode = load_last_position()

while True:

try:

check_file_size(LOG_FILE_PATH, "olt_monitor.log", max_size_mb=10)

check_file_size(SENT_MESSAGES_FILE, "sent_messages.txt", max_size_mb=10)

check_file_size(LAN_EVENTS_LOG, "lan_events.log", max_size_mb=10)

if not os.path.exists(LOG_FILE):

logging.error(f"Файл логу {LOG_FILE} не існує. Очікування 60 секунд")

time.sleep(60)

continue

current_inode = os.stat(LOG_FILE).st_ino

if current_inode != last_inode:

logging.info(f"Виявлено новий inode для {LOG_FILE}, скидання позиції")

last_pos, last_inode = 0, current_inode

with open(LOG_FILE, "r", encoding="utf-8") as f:

new_pos = parse_log(f, last_pos, sent_messages)

if new_pos != last_pos:

save_last_position(new_pos)

last_pos = new_pos

time.sleep(CHECK_INTERVAL)

except Exception as e:

logging.error(f"Критична помилка при обробці логу: {e}")

time.sleep(60)

# Планувальник для щоденного звіту

def run_scheduler():

sent_messages = load_sent_messages()

schedule.every().day.at(REPORT_TIME).do(send_lan_summary_to_telegram, sent_messages)

while True:

schedule.run_pending()

time.sleep(60)

if __name__ == "__main__":

try:

setup_logging_and_messages()

# Перевіряємо аргумент командного рядка

if len(sys.argv) > 1 and sys.argv[1] == "--manual-report":

manual_lan_summary()

else:

# Запускаємо планувальник у окремому потоці

scheduler_thread = threading.Thread(target=run_scheduler, daemon=True)

scheduler_thread.start()

monitor_log()

except Exception as e:

logging.error(f"Помилка запуску програми: {e}")

raise