Puis-je appeler des fonctions ou changer des variables via eventlet.backdoor en Python?

Question

J'ai écrit ce code minimal pour expliquer mon cas:

import threading 
import time 
import eventlet 
from eventlet import backdoor 

eventlet.monkey_patch() 

global should_printing 
should_printing = True 

def turn_off_printing(): 
    global should_printing 
    should_printing = not should_printing 

def printing_function(): 
    global should_printing 
    while should_printing == True: 
     print "printing" 
     time.sleep(1) 

def console(): 
    while True: 
     print "inside console" 
     time.sleep(1) 

if __name__ == '__main__': 
    eventlet.spawn(backdoor.backdoor_server, eventlet.listen(('localhost', 3000))) 

    thread = threading.Thread(target=printing_function) 
    thread.start() 

    thread = threading.Thread(target=console) 
    thread.start() 

Après son exécution, je me connecte via telnet, importer mon module et appeler turn_off_printing(). Mais ça ne marche pas. Est-ce que j'ai fait une erreur, ou ce n'est pas possible?

Answer 1

Comme fthinker dit dans le commentaire ci-dessus:

Il ne ressemble pas à le serveur de porte dérobée utilise le même espace de noms. La saisie des noms de fonctions indique qu'ils n'étaient pas définis et que votre variable 'should_printing' est également indéfinie. J'ai testé cela pendant que telnetted dans l'interpréteur mis en place par le serveur de porte dérobée.

(si la réponse de fthinker comme poste de réponse que je vais supprimer ce message)

Answer 2

Vous ne pouvez pas accéder à should_printing car le module __main__ est différent du module importé, même si elles sont le même module. Vérifiez les détails here

the executing script runs in a module named __main__, importing the 
script under its own name will create a new module unrelated to 
__main__. 

Answer 3

Assurez-vous d'indiquer toutes les variables/fonctions que vous souhaitez accéder en invoquant porte dérobée

if __name__ == '__main__': 
    s=eventlet.spawn(backdoor.backdoor_server, eventlet.listen(('localhost', 3000)), globals()) 

    thread1 = threading.Thread(target=printing_function) 
    thread1.start() 

    s.wait() 

Maintenant should_printing doit être visible sur l'interpréteur Python en cours d'exécution sur le port 3000 et sa mise en à false arrêterait d'imprimer