Jump Server comentada..

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from paramiko import SSHClient, AutoAddPolicy, ProxyCommand
from json import load

class SSHManager:
    def __init__(self, host, username, password, jump_host=None, jump_username=None, jump_password=None):
        self.host = host
        self.username = username
        self.password = password
        self.jump_host = jump_host
        self.jump_username = jump_username
        self.jump_password = jump_password
        self.client = None
        self.load_credentials()

    def load_credentials(self):
        if self.jump_host:
            self.client = SSHClient()
            self.client.set_missing_host_key_policy(AutoAddPolicy())
            self.client.connect(
                self.jump_host,
                username=self.jump_username,
                password=self.jump_password,
            )

    def connect(self):
        try:
            if not self.client:
                self.client = SSHClient()
                self.client.set_missing_host_key_policy(AutoAddPolicy())
                if self.jump_host:
                    proxy_cmd = ProxyCommand(f"ssh -q -W %h:%p {self.jump_host}")
                    self.client.connect(
                        self.host,
                        username=self.username,
                        password=self.password,
                        sock=proxy_cmd,
                    )
                else:
                    self.client.connect(
                        self.host,
                        username=self.username,
                        password=self.password,
                    )
        except Exception as e:
            raise RuntimeError(f"Erro ao conectar: {e}")

    def execute_command(self, command):
        try:
            _, stdout, _ = self.client.exec_command(command)
            return stdout.read().decode('utf-8')
        except Exception as e:
            raise RuntimeError(f"Erro ao executar comando: {e}")

    def close(self):
        if self.client:
            self.client.close()

def ler_ips_do_arquivo(nome_arquivo):
    with open(nome_arquivo, 'r') as file:
        return [line.strip() for line in file.readlines()]

def main():
    try:
        # Substitua pelos dados do seu servidor intermediário (jump server)
        jump_host = 'jump_server_ip'  # IP do servidor intermediário
        jump_username = 'user1'        # Nome de usuário do servidor intermediário
        jump_password = 'passw1'        # Senha do servidor intermediário

        arquivo_ips = 'ips.txt'          # Substitua pelo nome do seu arquivo de IPs
        arquivo_comandos = 'comandos.txt'  # Substitua pelo nome do seu arquivo de comandos

        ips = ler_ips_do_arquivo(arquivo_ips)
        comandos = [line.strip() for line in open(arquivo_comandos, 'r').readlines()]

        total_roteadores = len(ips)
        roteadores_acessados = 0
        roteadores_nao_acessados = 0

        with open('relatorio.txt', 'w') as relatorio:
            for ip in ips:
                try:
                    # Substitua pelos dados do seu roteador final
                    ssh_manager = SSHManager(
                        ip,
                        username='user2',   # Nome de usuário do roteador final
                        password='passw2',   # Senha do roteador final
                        jump_host=jump_host,
                        jump_username=jump_username,
                        jump_password=jump_password
                    )
                    ssh_manager.connect()

                    resultados = [ssh_manager.execute_command(comando) for comando in comandos]

                    if len(resultados) >= 2:  # Verificar se há pelo menos dois elementos na lista resultados
                        roteadores_acessados += 1
                        relatorio.write(f'{ip} - LOG OK\n')

                        with open(f'ANTES_{ip}.log', 'w') as log_antes:
                            log_antes.write(resultados[0])  # Supondo que o resultado do primeiro comando seja o log antes

                        with open(f'DEPOIS_{ip}.log', 'w') as log_depois:
                            log_depois.write(resultados[1])  # Supondo que o resultado do segundo comando seja o log depois

                    ssh_manager.close()

                except RuntimeError as e:
                    roteadores_nao_acessados += 1
                    relatorio.write(f'{ip} - LOG NOK - {e}\n')

        relatorio.write(f'\nNúmero de roteadores: {total_roteadores}\n')
        relatorio.write(f'Roteadores acessados: {roteadores_acessados}\n')
        relatorio.write(f'Roteadores não acessados: {roteadores_nao_acessados}\n')

    except Exception as e:
        print(f"Erro: {e}")

if __name__ == "__main__":
    main()