自动化服务器重启工具reboot-p：轻松实现高效重启

一、使用介绍

reboot-p是一款基于Python开发的自动化服务器重启工具。通过使用reboot-p，你能够轻松实现定时或者手动重启服务器，从而提升服务器的性能和稳定性。

使用reboot-p的好处在于，它能够帮你省去手动登录服务器执行重启操作的麻烦，而且能够轻松实现配置管理和计划管理，提高效率。

下面是使用reboot-p的步骤说明：

1.安装reboot-p

pip install reboot-p

2.配置服务器信息

reboot-p config -s SERVER_IP -u USERNAME -p PASSWORD

3.检查服务器列表

reboot-p list # 查看已经配置好的服务器列表

4.添加计划任务

reboot-p add -s SERVER_NAME -t TASK_NAME -i INTERVAL -t TIME_ZONE --start-hour START_HOUR --end-hour END_HOUR

5.执行任务

reboot-p run -t TASK_NAME

6.查看任务日志

reboot-p logs -t TASK_NAME

通过以上6个步骤，即可轻松使用reboot-p实现服务器重启。

二、定时任务管理

reboot-p提供了计划任务管理的功能，使得用户可以通过简单配置实现自动化的重启操作。下面是计划任务管理的几个方面的详细阐述：

1.添加计划任务

添加计划任务需要设置服务器、任务名称、间隔时间、时区、重启时间段等，在执行时，reboot-p会按照设定的时间自动执行重启操作，从而实现高效管理。

reboot-p add -s SERVER_NAME -t TASK_NAME -i INTERVAL -t TIME_ZONE --start-hour START_HOUR --end-hour END_HOUR

2.查看任务列表

reboot-p提供了list命令可以帮助你查看已经配置好的计划任务列表，方便你进行任务的管理和维护。使用方法如下：

reboot-p list

3.编辑计划任务

在实际场景中，你可能需要对已经配置好的任务进行调整，reboot-p提供了edit命令帮助你进行任务编辑，具体使用方法如下：

reboot-p edit -s SERVER_NAME -t TASK_NAME -i INTERVAL -t TIME_ZONE --start-hour START_HOUR --end-hour END_HOUR

4.删除计划任务

如果不需要某个计划任务，你可以使用delete命令来删除对应的任务。使用方法如下：

reboot-p delete -t TASK_NAME

三、手动重启管理

除了定时任务重启，reboot-p还提供了手动重启的功能。通过手动重启，你可以灵活地根据需求执行重启操作。下面是手动重启的几个方面的详细说明：

1.手动重启

手动重启非常简单，只需要在命令行中执行下面的命令即可：

reboot-p reboot -s SERVER_NAME

2.查看服务器状态

reboot-p提供了status命令可以帮助你查看服务器当前的状态，具体使用方法如下：

reboot-p status -s SERVER_NAME

3.手动关机

在某些特殊的情况下，你可能需要手动关机，reboot-p也提供了shutdown命令帮助你实现服务器的关机。使用方法如下：

reboot-p shutdown -s SERVER_NAME

四、代码示例

下面是reboot-p的核心代码，你可以参考它进行二次开发和灵活扩展：

import paramiko
import argparse
import yaml
import time
import logging
import logging.handlers

logging.basicConfig()
logger = logging.getLogger('reboot-p')
logger.setLevel(logging.INFO)
handler = logging.handlers.RotatingFileHandler('reboot-p.log', maxBytes=20 * 1024 * 1024, backupCount=5)
handler.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(message)s"))
logger.addHandler(handler)

class RebootClient:

    def __init__(self, server_config):
        self.ssh = paramiko.SSHClient()
        self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        self.ssh.connect(server_config['ip'], username=server_config['username'], password=server_config['password'])

    def reboot(self):
        try:
            logger.info('开始重启服务器...')
            self.ssh.exec_command('sudo reboot')
            logger.info('重启命令已发送，请稍等...')
            time.sleep(60)
            logger.info('重启成功！')
        except Exception as e:
            logger.error('重启失败：{}'.format(str(e)))
        finally:
            self.ssh.close()

    def shutdown(self):
        try:
            logger.info('开始关机操作...')
            self.ssh.exec_command('sudo shutdown -h now')
            logger.info('关机命令已发送，请稍等...')
            time.sleep(5)
            logger.info('关机成功！')
        except Exception as e:
            logger.error('关机失败：{}'.format(str(e)))
        finally:
            self.ssh.close()

    def check_status(self):
        try:
            stdin, stdout, stderr = self.ssh.exec_command('uptime')
            lines = stdout.readlines()
            logger.info('服务器{}当前状态：{}'.format(self.name, lines[0].strip()))
        except Exception as e:
            logger.error('状态查询失败：{}'.format(str(e)))
        finally:
            self.ssh.close()

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='reboot-p: a simple tool for rebooting remote server')
    parser.add_argument('command', help='command to run: config, add, delete, edit, list, run, logs, reboot, shutdown, status')
    parser.add_argument('-s', '--server-name', help='server name', dest='name')
    parser.add_argument('-i', '--interval', help='reboot interval in minutes', type=int)
    parser.add_argument('-t', '--timezone', help='time zone for task', default='Asia/Shanghai')
    parser.add_argument('--start-hour', help='start hour for reboot in 24 format', type=int)
    parser.add_argument('--end-hour', help='end hour for reboot in 24 format', type=int)
    parser.add_argument('-u', '--username', help='server username', dest='username')
    parser.add_argument('-p', '--password', help='server password', dest='password')
    parser.add_argument('--task-name', help='task name')
    args = parser.parse_args()

    if args.command == 'config':
        with open('config.yml', 'w') as f:
            yaml.dump({'servers': []}, f, default_flow_style=False)
        print('配置文件已创建，请编辑config.yml文件，并重新运行reboot-p')

    with open('config.yml', 'r') as f:
        config = yaml.load(f, Loader=yaml.FullLoader)

    if args.command == 'add':
        server_config = [s for s in config['servers'] if s['name'] == args.name][0]
        if not server_config:
            print('未找到服务器 {}'.format(args.name))
            exit(1)

        tasks = []
        if 'tasks' in server_config:
            tasks = server_config['tasks']

        task = {
            'name': args.task_name,
            'interval': args.interval,
            'timezone': args.timezone,
            'start_hour': args.start_hour,
            'end_hour': args.end_hour
        }
        tasks.append(task)
        server_config['tasks'] = tasks

        with open('config.yml', 'w') as f:
            yaml.dump(config, f, default_flow_style=False)
            print('服务器 {} 添加任务成功！'.format(args.name))

    elif args.command == 'delete':
        server_config = [s for s in config['servers'] if s['name'] == args.name][0]
        if not server_config:
            print('未找到服务器 {}'.format(args.name))
            exit(1)

        tasks = []
        if 'tasks' in server_config:
            tasks = server_config['tasks']

        tasks = [t for t in tasks if t['name'] != args.task_name]
        server_config['tasks'] = tasks

        with open('config.yml', 'w') as f:
            yaml.dump(config, f, default_flow_style=False)
            print('服务器 {} 删除任务成功！'.format(args.name))

    elif args.command == 'edit':
        server_config = [s for s in config['servers'] if s['name'] == args.name][0]
        if not server_config:
            print('未找到服务器 {}'.format(args.name))
            exit(1)

        tasks = []
        if 'tasks' in server_config:
            tasks = server_config['tasks']

        task = [t for t in tasks if t['name'] == args.task_name][0]
        task['interval'] = args.interval
        task['timezone'] = args.timezone
        task['start_hour'] = args.start_hour
        task['end_hour'] = args.end_hour

        with open('config.yml', 'w') as f:
            yaml.dump(config, f, default_flow_style=False)
            print('服务器 {} 编辑任务成功！'.format(args.name))

    elif args.command == 'list':
        for server in config['servers']:
            print('服务器：{}'.format(server['name']))
            tasks = []
            if 'tasks' in server:
                tasks = server['tasks']
            for task in tasks:
                print('    任务：{}'.format(task['name']))
                print('    间隔时间：{}分钟'.format(task['interval']))
                print('    时区：{}'.format(task['timezone']))
                print('    重启时间：{}点到{}点'.format(task['start_hour'], task['end_hour']))

    elif args.command == 'run':
        server_config = [s for s in config['servers'] if s['name'] == args.name][0]
        if not server_config:
            print('未找到服务器 {}'.format(args.name))
            exit(1)

        tasks = []
        if 'tasks' in server_config:
            tasks = server_config['tasks']
        
        task = [t for t in tasks if t['name'] == args.task_name][0]
        client = RebootClient(server_config)
        client.reboot()
    
    elif args.command == 'logs':
        logger.setLevel(logging.DEBUG)
        logger.handlers.clear()
        handler = logging.handlers.RotatingFileHandler('reboot-p.log', maxBytes=20 * 1024 * 1024, backupCount=5)
        handler.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(message)s"))
        logger.addHandler(handler)

    elif args.command == 'reboot':
        server_config = [s for s in config['servers'] if s['name'] == args.name][0]
        if not server_config:
            print('未找到服务器 {}'.format(args.name))
            exit(1)

        client = RebootClient(server_config)
        client.reboot()

    elif args.command == 'shutdown':
        server_config = [s for s in config['servers'] if s['name'] == args.name][0]
        if not server_config:
            print('未找到服务器 {}'.format(args.name))
            exit(1)

        client = RebootClient(server_config)
        client.shutdown()

    elif args.command == 'status':
        server_config = [s for s in config['servers'] if s['name'] == args.name][0]
        if not server_config:
            print('未找到服务器 {}'.format(args.name))
            exit(1)

        client = RebootClient(server_config)
        client.check_status()