PyEZ RpcTimeoutError 假性超时处理与健壮性提交机制

import time
from jnpr.junos import Device
from jnpr.junos.utils.config import Config
from jnpr.junos.exception import ConnectError, RpcTimeoutError, LockError, ConfigLoadError, CommitError

# 假设这些常量在实际应用中已定义
DEVICE_TIMEOUT = 360  # RPC超时值，单位秒
RETRY_DELAY = 5       # 重试间隔，单位秒

class JunosDeviceConfigurator:
    def __init__(self, user, password, hostname, logger) -> None:
        self.user = user
        self.password = password
        self._hostname = hostname
        self.logger = logger
        self.device = None
        # 可以在此处设置全局的Device超时
        Device.auto_probe = 15
        Device.timeout = DEVICE_TIMEOUT

    def connect(self) -> bool:
        """
        连接到Juniper设备。
        """
        try:
            self.device = Device(
                host=self._hostname, 
                user=self.user, 
                passwd=self.password, 
                port=22, huge_tree=True, 
                gather_facts=True,
                timeout=DEVICE_TIMEOUT)
            self.device.open()
            self.device.timeout = DEVICE_TIMEOUT # 再次确保设备实例的超时设置
            self.logger.info(f'Connected to {self._hostname}')
            return True
        except ConnectError as err:
            self.logger.error(f'Connection to {self._hostname} failed: {str(err)}')
            return False
        except Exception as err:
            self.logger.error(f'Error connecting to {self._hostname}: {str(err)}')
            return False

    def commit_config(self, commands: list, mode='exclusive', max_retries=2) -> bool:
        """
        使用PyEZ向Juniper设备提交配置更改。

        Args:
            commands (list): 包含Junos OS配置命令的列表。
            mode (str, optional): 配置模式，默认为'exclusive'。
            max_retries (int, optional): 遇到LockError或RpcTimeoutError时的最大重试次数。

        Returns:
            bool: 如果提交成功则返回True，否则返回False。
        """
        if not self.device:
            if not self.connect():
                self.logger.error(f'Failed to connect to {self._hostname} before commit.')
                return False

        for retry_attempt in range(max_retries + 1):
            try:
                with Config(self.device, mode=mode) as cu:
                    for command in commands:
                        cu.load(command, format='set')

                    self.logger.info(f'Attempt {retry_attempt + 1}/{max_retries + 1}: Trying to commit candidate configuration on {self._hostname}.')
                    cu.commit(timeout=DEVICE_TIMEOUT)

                    # 如果commit成功，直接返回True
                    return True
            except RpcTimeoutError as e:
                # 捕获RpcTimeoutError后，检查配置差异
                if cu.diff() is not None:
                    # 如果仍有差异，说明commit可能确实失败了，需要重试
                    self.logger.warning(f'RpcTimeoutError: {e}. Configuration differences still exist. Retrying in {RETRY_DELAY} seconds. (Attempt {retry_attempt + 1}/{max_retries + 1})')
                    time.sleep(RETRY_DELAY)
                else:
                    # 如果没有差异，说明commit实际上已成功，是“假性”超时
                    self.logger.info(f'RpcTimeoutError detected, but cu.diff() is None. Assuming commit was successful. (Workaround applied)')
                    return True # 假性超时，返回True
            except LockError as e:
                self.logger.warning(f'LockError: {e}. Retrying in {RETRY_DELAY} seconds. (Attempt {retry_attempt + 1}/{max_retries + 1})')
                time.sleep(RETRY_DELAY)
            except ConfigLoadError as e:
                # 配置加载错误通常不是瞬时错误，可能需要人工干预，但此处也加入重试机制
                self.logger.warning(f'ConfigLoadError: {e}. Retrying in {RETRY_DELAY} seconds. (Attempt {retry_attempt + 1}/{max_retries + 1})')
                time.sleep(RETRY_DELAY)
            except CommitError as e:
                # 提交错误通常是配置语法或逻辑问题，不太可能通过重试解决
                self.logger.error(f'CommitError: {e}. This is likely a configuration issue. Aborting. (Attempt {retry_attempt + 1}/{max_retries + 1})')
                break # 这种错误通常不值得重试
            except Exception as e:
                self.logger.error(f'An unexpected error occurred: {str(e)}. Aborting. (Attempt {retry_attempt + 1}/{max_retries + 1})')
                break # 捕获其他未知错误并终止

        self.logger.error(f'Failed to commit configuration on {self._hostname} after {max_retries + 1} attempts.')
        return False

# 示例用法 (假设存在一个logger实例和设备连接信息)
if __name__ == "__main__":
    import logging
    logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
    logger = logging.getLogger(__name__)

    # 替换为你的设备信息
    JUNOS_HOST = "your_junos_device_ip"
    JUNOS_USER = "your_username"
    JUNOS_PASSWD = "your_password"

    configurator = JunosDeviceConfigurator(JUNOS_USER, JUNOS_PASSWD, JUNOS_HOST, logger)

    # 示例配置命令
    commands_to_commit = [
        "delete interfaces ge-0/0/0 unit 500",
        "delete class-of-service interfaces ge-0/0/0 unit 500",
        "delete routing-options rib inet6.0 static route 2001:db8::1/64"
    ]

    if configurator.commit_config(commands_to_commit):
        logger.info(f"Configuration committed successfully on {JUNOS_HOST}.")
    else:
        logger.error(f"Failed to commit configuration on {JUNOS_HOST}.")

    if configurator.device and configurator.device.connected:
        configurator.device.close()
        logger.info(f"Disconnected from {JUNOS_HOST}.")