2010-10-26 13 views
6

http://docs.python.org/library/pty.html कहते हैं -अजगर pty.fork - यह कैसे काम करता

pty.fork() ¶ कांटा। बच्चे के नियंत्रण टर्मिनल को छद्म-टर्मिनल से कनेक्ट करें। वापसी मूल्य है (पीआईडी, एफडी)। ध्यान दें कि बच्चे को 0 0 मिलता है, और एफडी अमान्य है। माता-पिता का वापसी मूल्य बच्चे का पिड होता है, और एफडी एक फ़ाइल डिस्क्रिप्टर है जो बच्चे के नियंत्रण टर्मिनल से जुड़ा होता है (और बच्चे के मानक इनपुट और आउटपुट तक)।

इसका क्या अर्थ है? प्रत्येक प्रक्रिया में 3 एफडी (stdin, stdout, stderr) है। क्या यह अब इन एफडीएस को प्रभावित करता है? क्या बाल प्रक्रिया में इनमें से कोई भी एफडीएस नहीं होगा? मैं उलझन में हूँ .-- पूरी तरह से।

उत्तर

2

"और एफडी एक फ़ाइल डिस्क्रिप्टर है जो बच्चे के नियंत्रण टर्मिनल से जुड़ा हुआ है" -> बच्चे की प्रक्रिया में कोई फर्क नहीं पड़ता है, यह सामान्य रूप से stdin/out तक पहुंचने में सक्षम होगा (मुझे stderr के बारे में पता नहीं है)। केवल अंतर यह है कि "पाइप" के दूसरी तरफ एक टर्मिनल नहीं है जहां कोई उपयोगकर्ता पढ़ रहा/टाइप कर रहा हो, लेकिन अभिभावक प्रक्रिया जो पहुंच सकती है वह लौटाई गई एफडी द्वारा है।

0

धन्यवाद जॉनी.यह मुझे समझ में आया। जब pty.fork() का आह्वान किया जाता है। पैरेंट प्रक्रिया ptmx मास्टर से जुड़ा हुआ है। माता-पिता कीबोर्ड से इनपुट या डेटा से डेटा के लिए इंतजार करेंगे।

बच्चे अपने stdin, stdout और stderr बंद कर देता है। और डुप्लिकेट गुलाम stdin, stdout.stderr। अब बच्चे ने एक कार्यक्रम निष्पादित किया है (बीसी कहें)। कार्यक्रम इनपुट के लिए इंतजार कर रहा है, जब आप 1 + 1 टाइप करते हैं - यह मास्टर/पास हो जाता है (बच्चे और दास दोनों को याद रखें बच्चे/दास द्वारा कुछ stdin, stdout, stderr)। मास्टर अपने उत्तर "2" की गणना करता है और stdout में लिखता है- चूंकि अभिभावक मास्टर-बिट से डेटा की प्रतीक्षा कर रहा है "2" उठाता है और stdout में लिखता है।

छद्म टर्मिनल पर कुछ अच्छे पुराने सी कार्यक्रमों के माध्यम से जाने के बाद मैं इस निष्कर्ष पर आया :) मुझे नहीं लगता कि पाइथन का तर्क उनके से अलग नहीं होगा। एचटीएच कोई

11

मुझे लगता है कि मुझे पाइथन में pty.fork के लिए अंततः न्यूनतम उदाहरण मिला - और चूंकि मुझे एक समान उदाहरण खोजने में बेहद मुश्किल लगता है, इसलिए मैं इसे @ जॉनी के उत्तर के उदाहरण के रूप में यहां पोस्ट कर रहा हूं। यह अनिवार्य रूप पर आधारित है:

(" master_open() और slave_open 2.0 के बाद अमान्य हो जाने के")

विशेष रूप से गंदे बिट्स दस्तावेज ढूंढ रहे हैं जो अभी भी master_open() को संदर्भित करता है जो अप्रचलित है; और तथ्य यह है कि pty.fork एक बच्चे की प्रक्रिया, स्पॉन नहीं होने तक फ़ाइल डिस्क्रिप्टर (फोर्क विधि द्वारा लौटाया गया) माता-पिता प्रक्रिया से पढ़ा जाता है! (ध्यान दें कि os.fork में ऐसी कोई आवश्यकता नहीं है) इसके अलावा, ऐसा लगता है कि os.fork थोड़ा और पोर्टेबल है (कुछ टिप्पणियां पढ़ें जो pty.fork कुछ प्लेटफ़ॉर्म पर काम नहीं करती हैं)।

#!/usr/bin/env python 
# pyecho.py 

import sys; 

print "pyecho starting..." 

while True: 
    print sys.stdin.readline().upper() 

... और फिर, यहाँ है:

फिर भी, यहाँ पहली बार एक स्क्रिप्ट (pyecho.py) कि (यह केवल मानक इनपुट से लाइनों पढ़ता है, और उन्हें वापस लिखते हैं अपरकेस में) एक निष्पादन रूप में कार्य करता है वास्तविक स्क्रिप्ट (यह आवश्यक होगा कि pyecho.py एक ही निर्देशिका में है):

#!/usr/bin/env python 

import sys 
import os 
import time 
import pty 

def my_pty_fork(): 

    # fork this script 
    try: 
    (child_pid, fd) = pty.fork() # OK 
    #~ child_pid, fd = os.forkpty()  # OK 
    except OSError as e: 
    print str(e) 

    #~ print "%d - %d" % (fd, child_pid) 
    # NOTE - unlike OS fork; in pty fork we MUST use the fd variable 
    # somewhere (i.e. in parent process; it does not exist for child) 
    # ... actually, we must READ from fd in parent process... 
    # if we don't - child process will never be spawned! 

    if child_pid == 0: 
    print "In Child Process: PID# %s" % os.getpid() 
    # note: fd for child is invalid (-1) for pty fork! 
    #~ print "%d - %d" % (fd, child_pid) 

    # the os.exec replaces the child process 
    sys.stdout.flush() 
    try: 
     #Note: "the first of these arguments is passed to the new program as its own name" 
     # so:: "python": actual executable; "ThePythonProgram": name of executable in process list (`ps axf`); "pyecho.py": first argument to executable.. 
     os.execlp("python","ThePythonProgram","pyecho.py") 
    except: 
     print "Cannot spawn execlp..." 
    else: 
    print "In Parent Process: PID# %s" % os.getpid() 
    # MUST read from fd; else no spawn of child! 
    print os.read(fd, 100) # in fact, this line prints out the "In Child Process..." sentence above! 

    os.write(fd,"message one\n") 
    print os.read(fd, 100)  # message one 
    time.sleep(2) 
    os.write(fd,"message two\n") 
    print os.read(fd, 10000)  # pyecho starting...\n MESSAGE ONE 
    time.sleep(2) 
    print os.read(fd, 10000)  # message two \n MESSAGE TWO 
    # uncomment to lock (can exit with Ctrl-C) 
    #~ while True: 
     #~ print os.read(fd, 10000) 


if __name__ == "__main__": 
    my_pty_fork() 

ठीक है, उम्मीद है कि इस मदद करता है किसी को,
चीयर्स!

+0

यह कोड मेरे लिए काम नहीं करता है। यहां आउटपुट है: http://pastebin.com/MjGUChTy –

3

pty.fork() का उपयोग करने का मुख्य बिंदु यह है कि लौटा हुआ स्यूडोटेर्मिनल (पीटीआई) फ़ाइल डिस्क्रिप्टर का उपयोग अलग-अलग तरीके से उत्पन्न प्रक्रिया के साथ संवाद करने के लिए किया जा सकता है, यानी। सीधे लिखने और इसके (छद्म-) टर्मिनल से पढ़ने के लिए - stdin/out/err के बजाए।

और जानकारी about pty's and tty's (स्टैक ओवरव्लो से) और a link to a simple example of using pty.fork() पर भी अधिक जानकारी है।

संबंधित मुद्दे