#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
自動清理 Linux 下的舊日志文件
功能：刪除指定目錄下超過指定天數(shù)的指定后綴文件
依賴：Python 3.6+（無需額外第三方庫）
"""
import os
import argparse
import time
from datetime import datetime, timedelta

def parse_args():
    """解析命令行參數(shù)"""
    parser = argparse.ArgumentParser(description="Linux 舊日志文件清理工具")
    # 必選參數(shù)：日志目錄
    parser.add_argument("-d", "--dir", required=True, help="日志文件所在目錄（必填）")
    # 可選參數(shù)：文件后綴，默認 .log
    parser.add_argument("-s", "--suffix", default=".log", help="需要清理的文件后綴（默認：.log）")
    # 可選參數(shù)：保留天數(shù)，默認 7 天
    parser.add_argument("-t", "--days", type=int, default=7, help="保留文件的天數(shù)（默認：7 天，超過則刪除）")
    return parser.parse_args()

def clean_old_files(log_dir, file_suffix, keep_days):
    """
    清理舊文件核心邏輯
    :param log_dir: 日志目錄路徑
    :param file_suffix: 目標文件后綴
    :param keep_days: 保留天數(shù)
    """
    # 校驗目錄是否存在
    if not os.path.isdir(log_dir):
        print(f"錯誤：目錄 {log_dir} 不存在，請檢查路徑是否正確")
        return
    # 計算過期時間閾值（當前時間 - 保留天數(shù)）
    expire_time = datetime.now() - timedelta(days=keep_days)
    # 遍歷目錄下所有文件
    for root, dirs, files in os.walk(log_dir):
        for file in files:
            # 篩選指定后綴的文件
            if file.endswith(file_suffix):
                file_path = os.path.join(root, file)
                # 獲取文件最后修改時間（Linux 時間戳轉(zhuǎn) datetime）
                mtime = os.path.getmtime(file_path)
                mtime_datetime = datetime.fromtimestamp(mtime)
                # 判斷文件是否過期
                if mtime_datetime < expire_time:
                    try:
                        # 刪除文件
                        os.remove(file_path)
                        print(f"已刪除過期文件：{file_path}")
                    except Exception as e:
                        print(f"刪除文件 {file_path} 失?。簕str(e)}")
    print("清理任務執(zhí)行完成！")

if __name__ == "__main__":
    # 解析參數(shù)
    args = parse_args()
    # 執(zhí)行清理邏輯
    clean_old_files(args.dir, args.suffix, args.days)

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Linux 舊日志文件清理工具（進階版）
功能：支持錯誤處理、日志記錄、dry-run 模擬、日志級別控制
依賴：Python 3.6+
"""
import os
import argparse
import time
import logging
from datetime import datetime, timedelta

def setup_logging(log_level, log_file=None):
    """配置日志系統(tǒng)"""
    # 日志級別映射
    level_map = {
        "DEBUG": logging.DEBUG,
        "INFO": logging.INFO,
        "WARNING": logging.WARNING,
        "ERROR": logging.ERROR
    }
    level = level_map.get(log_level.upper(), logging.INFO)
    
    # 日志格式
    formatter = logging.Formatter(
        "%(asctime)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s"
    )
    
    # 日志處理器（控制臺 + 文件）
    handlers = [logging.StreamHandler()]
    if log_file:
        file_handler = logging.FileHandler(log_file, encoding="utf-8")
        file_handler.setFormatter(formatter)
        handlers.append(file_handler)
    
    # 配置根日志
    logging.basicConfig(level=level, handlers=handlers)
    return logging.getLogger(__name__)

def parse_args():
    """解析命令行參數(shù)（強化版）"""
    parser = argparse.ArgumentParser(description="Linux 舊日志文件清理工具（進階版）")
    parser.add_argument("-d", "--dir", required=True, help="日志文件所在目錄（必填）")
    parser.add_argument("-s", "--suffix", default=".log", help="需要清理的文件后綴（默認：.log）")
    parser.add_argument("-t", "--days", type=int, default=7, help="保留文件的天數(shù)（默認：7 天）")
    parser.add_argument("--dry-run", action="store_true", help="模擬清理，不實際刪除文件")
    parser.add_argument("--log-level", default="INFO", choices=["DEBUG", "INFO", "WARNING", "ERROR"], help="日志級別（默認：INFO）")
    parser.add_argument("--log-file", help="日志文件路徑（默認僅輸出到控制臺）")
    return parser.parse_args()

def clean_old_files(log_dir, file_suffix, keep_days, dry_run, logger):
    """核心清理邏輯（帶日志與錯誤處理）"""
    try:
        if not os.path.isdir(log_dir):
            logger.error(f"目錄 {log_dir} 不存在，清理任務終止")
            return
        # 校驗目錄權(quán)限（是否可讀?。?
        if not os.access(log_dir, os.R_OK):
            logger.error(f"無權(quán)限訪問目錄 {log_dir}，請檢查權(quán)限配置")
            return
        
        expire_time = datetime.now() - timedelta(days=keep_days)
        logger.info(f"開始執(zhí)行清理任務：目錄={log_dir}，后綴={file_suffix}，保留天數(shù)={keep_days}")
        logger.debug(f"過期時間閾值：{expire_time.strftime('%Y-%m-%d %H:%M:%S')}")
        
        deleted_count = 0
        for root, dirs, files in os.walk(log_dir):
            logger.debug(f"遍歷目錄：{root}，包含文件數(shù)：{len(files)}")
            for file in files:
                if file.endswith(file_suffix):
                    file_path = os.path.join(root, file)
                    try:
                        mtime = os.path.getmtime(file_path)
                        mtime_datetime = datetime.fromtimestamp(mtime)
                        if mtime_datetime < expire_time:
                            if dry_run:
                                logger.info(f"[Dry-Run] 擬刪除過期文件：{file_path}（最后修改時間：{mtime_datetime.strftime('%Y-%m-%d %H:%M:%S')}）")
                            else:
                                os.remove(file_path)
                                logger.info(f"已刪除過期文件：{file_path}（最后修改時間：{mtime_datetime.strftime('%Y-%m-%d %H:%M:%S')}）")
                                deleted_count += 1
                    except PermissionError:
                        logger.warning(f"無權(quán)限操作文件：{file_path}，跳過該文件")
                    except Exception as e:
                        logger.error(f"處理文件 {file_path} 時出錯：{str(e)}", exc_info=True)
        
        logger.info(f"清理任務執(zhí)行完成！共處理過期文件 {deleted_count} 個（{'模擬模式，未實際刪除' if dry_run else '已實際刪除'}）")
    except Exception as e:
        logger.critical(f"清理任務意外終止：{str(e)}", exc_info=True)

if __name__ == "__main__":
    args = parse_args()
    # 初始化日志
    logger = setup_logging(args.log_level, args.log_file)
    # 執(zhí)行清理
    clean_old_files(args.dir, args.suffix, args.days, args.dry_run, logger)

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
服務狀態(tài)監(jiān)控與自動重啟工具
功能：定期檢測服務狀態(tài)，宕機時自動重啟，記錄全程日志
依賴：Python 3.6+，適用于 systemd 系統(tǒng)（CentOS 7+、Ubuntu 16.04+ 等）
"""
import os
import sys
import time
import logging
import argparse
import subprocess
from signal import signal, SIGINT

def setup_logging(log_level, log_file):
    """配置日志系統(tǒng)"""
    level_map = {"DEBUG": logging.DEBUG, "INFO": logging.INFO, "WARNING": logging.WARNING, "ERROR": logging.ERROR}
    level = level_map.get(log_level.upper(), logging.INFO)
    formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
    handlers = [logging.StreamHandler()]
    if log_file:
        file_handler = logging.FileHandler(log_file, encoding="utf-8")
        file_handler.setFormatter(formatter)
        handlers.append(file_handler)
    logging.basicConfig(level=level, handlers=handlers)
    return logging.getLogger(__name__)

def parse_args():
    """解析命令行參數(shù)"""
    parser = argparse.ArgumentParser(description="服務狀態(tài)監(jiān)控與自動重啟工具")
    parser.add_argument("-s", "--service", required=True, help="需要監(jiān)控的服務名稱（必填，如 nginx、mysql）")
    parser.add_argument("-i", "--interval", type=int, default=60, help="檢測間隔（秒，默認：60 秒）")
    parser.add_argument("--log-level", default="INFO", choices=["DEBUG", "INFO", "WARNING", "ERROR"], help="日志級別（默認：INFO）")
    parser.add_argument("--log-file", help="日志文件路徑（默認僅輸出到控制臺）")
    return parser.parse_args()

def execute_command(cmd):
    """
    執(zhí)行系統(tǒng)命令并返回結(jié)果
    :param cmd: 命令字符串
    :return: (return_code, stdout, stderr) 命令返回碼、標準輸出、標準錯誤
    """
    try:
        result = subprocess.run(
            cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, encoding="utf-8", timeout=10
        )
        return (result.returncode, result.stdout.strip(), result.stderr.strip())
    except subprocess.TimeoutExpired:
        return (-1, "", "命令執(zhí)行超時")
    except Exception as e:
        return (-2, "", f"命令執(zhí)行異常：{str(e)}")

def check_service_status(service_name, logger):
    """檢查服務運行狀態(tài)"""
    cmd = f"systemctl is-active {service_name}"
    ret_code, stdout, stderr = execute_command(cmd)
    if ret_code == 0:
        if stdout == "active":
            logger.debug(f"服務 {service_name} 運行正常（狀態(tài)：{stdout}）")
            return True
        else:
            logger.warning(f"服務 {service_name} 狀態(tài)異常（狀態(tài)：{stdout}）")
            return False
    else:
        logger.error(f"檢測服務 {service_name} 狀態(tài)失?。簕stderr}（返回碼：{ret_code}）")
        return False

def restart_service(service_name, logger):
    """重啟服務并返回結(jié)果"""
    logger.warning(f"開始嘗試重啟服務 {service_name}")
    cmd = f"systemctl restart {service_name}"
    # 重啟命令需要 root 權(quán)限，檢測當前用戶是否為 root
    if os.geteuid() != 0:
        logger.error("重啟服務需要 root 權(quán)限，請使用 sudo 運行腳本")
        return False
    ret_code, stdout, stderr = execute_command(cmd)
    if ret_code == 0:
        logger.info(f"服務 {service_name} 重啟命令執(zhí)行成功，等待 5 秒后驗證狀態(tài)")
        time.sleep(5)
        # 驗證重啟后狀態(tài)
        if check_service_status(service_name, logger):
            logger.info(f"服務 {service_name} 重啟成功并正常運行")
            return True
        else:
            logger.error(f"服務 {service_name} 重啟命令執(zhí)行成功，但狀態(tài)仍異常")
            return False
    else:
        logger.error(f"服務 {service_name} 重啟失?。簕stderr}（返回碼：{ret_code}）")
        return False

def signal_handler(signum, frame, logger):
    """處理 Ctrl+C 終止信號"""
    logger.info("收到終止信號，正在退出監(jiān)控程序...")
    sys.exit(0)

def start_monitor(service_name, interval, logger):
    """啟動服務監(jiān)控循環(huán)"""
    logger.info(f"服務監(jiān)控程序啟動：監(jiān)控服務={service_name}，檢測間隔={interval}秒")
    # 注冊 Ctrl+C 信號處理
    signal(SIGINT, lambda signum, frame: signal_handler(signum, frame, logger))
    while True:
        try:
            if not check_service_status(service_name, logger):
                # 服務異常，嘗試重啟
                if not restart_service(service_name, logger):
                    logger.critical(f"服務 {service_name} 重啟失敗，監(jiān)控程序退出")
                    break
            # 等待下一次檢測
            time.sleep(interval)
        except Exception as e:
            logger.error(f"監(jiān)控循環(huán)異常：{str(e)}", exc_info=True)
            time.sleep(interval)

if __name__ == "__main__":
    args = parse_args()
    logger = setup_logging(args.log_level, args.log_file)
    # 啟動監(jiān)控
    start_monitor(args.service, args.interval, logger)