Imprimer et pexpect de journalisation

J'ai un peu de code qui utilise pexpect à la commande d'un processus et de certaines impressions dans le code. L'objectif principal (dans cette question), c'est avoir l' pexpect de sortie et d'impressions enregistrées dans certains fichier journal. Le problème que j'ai rencontré est que le pexpect lignes (données envoyées et reçues) est mêlé avec les impressions sans logique apparente. Je m'attendais à ce que l'impression de cordes et de pexpect sorties seront enregistrées dans l'ordre où ils ont été émis.

Exemple de code est le suivant:

#!/usr/bin/env python

import pexpect
import time, sys, os

###############################################################################
# Subclass of file object to avoid recording extensive whitespace characters
class CleanFile(file):
    def write (self, text):
        # Remove the whitespaces
        out_text = ''
        # process the backspace properly
        bline = ''
        for c in text:
            if (ord(c) == 0x8):
                if (len(bline) == 0):
                    # Move the file pointer.
                    file.seek(self, -1, os.SEEK_CUR);
                else:
                    bline = bline[:-1]
            else:
                bline += c

        # remove whitespaces from inside a line
        out_text += ''.join(c for c in bline if (ord(c) >= 32 or ord(c) == 10));

        file.write(self, out_text);

###############################################################################
def main():
    fout = CleanFile ("options.log_file.log", 'w')

    sys.stdout = os.fdopen (sys.stdout.fileno(), 'w', 0)
    os.dup2 (fout.fileno(), sys.stdout.fileno());

    p = pexpect.spawn ('tclsh')
    p.logfile = fout

    print "Got into tclsh."
    p.sendline('ls');
    p.expect (['%',pexpect.EOF])

    p.sendline('info tclversion');
    p.expect (['%',pexpect.EOF])

    print "Got the version\n"

    p.sendline('info commands %');
    p.expect (['%',pexpect.EOF])

    p.sendline('exit');

    print 'Ended session'

###############################################################################
if __name__ == "__main__":
    main()

C'est le fichier journal de sortie contenu:

Got into tclsh.
ls
% lsinfo tclversion

log  options.log_file.log  pexpect_test.py  runtests.py  runtests_steinway.py
% info tclversionGot the version

info commands %

8.4
% info commands %exit
Ended session

Est-il possible de faire la pexpect et de sortie d'impression séquentielle?

Mise à jour: Basé sur le pexpect page de manuel: "s'il vous Plaît noter, cependant, que la mise en mémoire tampon peut influer sur ce comportement, depuis
l'entrée arrive, des morceaux". De sorte qu'il peut potentiellement affecter l'exploitation forestière.

OriginalL'auteur ilya1725 | 2012-11-27

  1. 2

    Si vous pouvez attendre jusqu'à la fin du script pour les résultats, de ne pas définir un fichier journal pour pexpect commandes, enregistrer les résultats des commandes à des variables, et d'imprimer le tout à la fin.

    Notez également que vous êtes absent de la sortie de la info commands de commande. Ceci peut être corrigé par l'ajout d'un expect() pour attendre le tclsh interprète de début et de retrait de la '%' a partir de la fin de la commande. J'ai supposé que c'était une faute de frappe.

    Modifier la fonction principale:

    def main():                                                          
    fout = CleanFile ("options.log_file.log", 'w')                   

    sys.stdout = os.fdopen (sys.stdout.fileno(), 'w', 0)             
    os.dup2 (fout.fileno(), sys.stdout.fileno());                    

    p = pexpect.spawn ('tclsh')                                      
    p.expect (['%',pexpect.EOF])                                     

    p.sendline('ls');                                                
    p.expect (['%',pexpect.EOF])                                     
    ls = p.before                                                    

    p.sendline('info tclversion');                                   
    p.expect (['%',pexpect.EOF])                                     
    tclversion = p.before                                            

    p.sendline('info commands');                                     
    p.expect (['%',pexpect.EOF])                                     
    commands = p.before                                              

    p.sendline('exit');                                              
    p.close()                                                        

    print "Got into tclsh."                                          
    print ls                                                         
    print tclversion                                                 
    print "Got the version\n"                                        
    print commands                                                   
    print "Ended session"

    La sortie est alors:

    Got into tclsh.                                                      
 ls                                                                  
options.log_file.log  pexpect_test.py                                

 info tclversion                                                     
8.5                                                                  

Got the version                                                      

 info commands                                           
tell socket subst open eof pwd glob list pid exec auto_load_index time unknown  
eval lassign lrange fblocked lsearch auto_import gets case lappend proc break v 
ariable llength auto_execok return linsert error catch clock info split array i 
f fconfigure concat join lreplace source fcopy global switch auto_qualify updat 
e close cd for auto_load file append lreverse format unload read package set bi 
nary namespace scan apply trace seek while chan flush after vwait dict continue 
 uplevel foreach lset rename fileevent regexp lrepeat upvar encoding expr unset 
 load regsub history interp exit puts incr lindex lsort tclLog string           

Ended session
    Bonne idée. Va juste l'impression tout de suite trop de travail? Il devrait alors être contrôlé par le print méthode. Une question que je me pose est: faut - p.before + p.match + p.after être utilisé?
    L'impression de droit de suite ne fonctionne pas parce que les données sont renvoyées de manière asynchrone comme dans votre script d'origine. p.avant de retourne le tout avant de chaîne correspondante. Que le contenu de la chaîne est prompt, tous les résultats de la commande a déjà venus avant.

    OriginalL'auteur Edu