Se produjo un error de excepción "Excepción en el subproceso Thread-1 (muy probablemente se produjo durante el apagado del intérprete)" que al usar Paramiko

Question

Escribí un programa simple para crear una conexión SSH a través de paramiko y luego ejecuté un comando simple. Pero siempre genera un error de excepción: -

Exception in thread Thread-1 (most likely raised during interpreter shutdown): Traceback (most recent call last): File "/usr/lib/python2.7/threading.py", line 530, in __bootstrap_inner
File "/usr/lib/python2.7/site-packages/paramiko/transport.py", line 1574, in run : 'NoneType' object has no attribute 'error'

El programa que he escrito es el siguiente: -

class Session: 

     def __init__(self, ipaddr, username, password): 
     self.ipaddr = ipaddr 
     self.username = username 
     self.password = password 

     self.connect() 

     def connect(self): 
     try: 
      time.sleep(1) 
      self.ssh = paramiko.SSHClient() 
      self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) 

      try: 
      self.ssh.connect(self.ipaddr, username=self.username, password=self.password) 
      time.sleep(2) 
      except socket.error, e: 
      print e 
      self.ssh.close() 
      sys.exit() 

     except Exception, e: 
      print e 

    def executeCmd(self, cmd): 
    data = "" 
    try: 
     stdin, stdout, stderr = self.ssh.exec_command(cmd) 
     data = stdout.read() 
    except SSHException, e: 
     print "Error: ", e 
     errorMsg = "Error: %s" %traceback.format_exc() 
     print errorMsg 

    return data 

    def __del__(self): 
    self.ssh.close() 

de cómo resolver esta excepción? Por favor ayuda.

Gracias

Answer 1

Aquí hay un código de ejemplo que he encontrado y utilizado anteriormente y se ve muy bien a mí.

import os 
import tempfile 
import paramiko 

class Connection(object): 
     """Connects and logs into the specified hostname. 
     Arguments that are not given are guessed from the environment.""" 

     def __init__(self, 
     host, 
     username = None, 
     private_key = None, 
     password = None, 
     port = 22, 
     ): 
       self._sftp_live = False 
       self._sftp = None 
       if not username: 
         username = os.environ['LOGNAME'] 

       # Log to a temporary file. 
       templog = tempfile.mkstemp('.txt', 'ssh-')[1] 
       paramiko.util.log_to_file(templog) 

       # Begin the SSH transport. 
       self._transport = paramiko.Transport((host, port)) 
       self._tranport_live = True 
       # Authenticate the transport. 
       if password: 
       # Using Password. 
         self._transport.connect(username = username, password = password) 
       else: 
       # Use Private Key. 
         if not private_key: 
         # Try to use default key. 
           if os.path.exists(os.path.expanduser('~/.ssh/id_rsa')): 
             private_key = '~/.ssh/id_rsa' 
           elif os.path.exists(os.path.expanduser('~/.ssh/id_dsa')): 
             private_key = '~/.ssh/id_dsa' 
         else: 
           raise TypeError, "You have not specified a password or key." 
         private_key_file = os.path.expanduser(private_key) 
         rsa_key = paramiko.RSAKey.from_private_key_file(private_key_file) 
         self._transport.connect(username = username, pkey = rsa_key) 

     def _sftp_connect(self): 
       """Establish the SFTP connection.""" 
       if not self._sftp_live: 
         self._sftp = paramiko.SFTPClient.from_transport(self._transport) 
         self._sftp_live = True 
     def get(self, remotepath, localpath = None): 
       """Copies a file between the remote host and the local host.""" 
       if not localpath: 
         localpath = os.path.split(remotepath)[1] 
       self._sftp_connect() 
       self._sftp.get(remotepath, localpath) 

     def put(self, localpath, remotepath = None): 
       """Copies a file between the local host and the remote host.""" 
       if not remotepath: 
         remotepath = os.path.split(localpath)[1] 
       self._sftp_connect() 
       self._sftp.put(localpath, remotepath) 

     def execute(self, command): 
       """Execute the given commands on a remote machine.""" 
       channel = self._transport.open_session() 
       channel.exec_command(command) 
       output = channel.makefile('rb', -1).readlines() 
       if output: 
         return output 
       else: 
         return channel.makefile_stderr('rb', -1).readlines() 
     def close(self): 
       """Closes the connection and cleans up.""" 
       # Close SFTP Connection. 
       if self._sftp_live: 
         self._sftp.close() 
         self._sftp_live = False 
     # Close the SSH Transport. 
       if self._tranport_live: 
         self._transport.close() 
         self._tranport_live = False 
     def __del__(self): 
       """Attempt to clean up if not explicitly closed.""" 
       self.close()