उचित रूप से एक मल्टीप्रोसेसिंग। प्रबंधक कस्टम ऑब्जेक्ट को डिजाइन करना

Question

मैं multiprocessing.Manager() ऑब्जेक्ट का उपयोग करना चाहता हूं ताकि मैं एक सर्वर से जानकारी भेजने के लिए एक कार्यकर्ता से प्रबंधक को जानकारी भेज सकूं। मेरे पास डिस्क पर पीडीएफ लिखने के लगभग 10 उदाहरण हैं। मैं फिर मल्टीप्रोसेसिंग पैकेज में प्रबंधक ऑब्जेक्ट का उपयोग अपने एस 3 बाल्टी को भेजने के लिए करना चाहता था क्योंकि मैं स्थानीय सामग्री उत्पादन को रोकना नहीं चाहता हूं।

तो मैं सोच रहा था कि क्या मैं कस्टम मैनेजर ऑब्जेक्ट बनाता हूं, क्या यह ऐसा करने का सही तरीका है? प्रबंधक ऑब्जेक्ट को सबमिट की गई प्रत्येक प्रक्रिया कतारबद्ध होगी? या यदि मैं एकाधिक अपलोड कहता हूं, तो क्या प्रबंधक कुछ कॉल छोड़ देगा?

नीचे मैं क्या कर की सोच रहा हूँ का एक नमूना कोड है:

from multiprocessing.managers import BaseManager 

class UploadClass(object): 
    def upload(self, filePath, params, destUrl): 
     # do stuff 
     return results 

class MyManager(BaseManager): 
    pass 

MyManager.register('uploads', UploadClass) 

if __name__ == '__main__': 
    manager = MyManager() 
    manager.start() 
    upload = manager.uploads() 
    # do this wait for completion or do they perform this async 
    print upload.upload(r"<path>", {...}, "some url") 
    print upload.upload(r"<path>", {...}, "some url") 

Answer 1

सीधे आपके कुछ प्रश्नों के उत्तर देने के लिए:

प्रत्येक प्रक्रिया प्रबंधक वस्तु को प्रस्तुत पंक्तिबद्ध हो जाएगा?

Manager सर्वर ने एक नया धागा आने वाली प्रत्येक अनुरोध को पूरा करने spawns, तो अपने सभी अनुरोधों तुरन्त संभाला जा रहा प्रारंभ होगा।

def serve_forever(self): 
    ''' 
    Run the server forever 
    ''' 
    current_process()._manager_server = self 
    try: 
     try: 
      while 1: 
       try: 
        c = self.listener.accept() 
       except (OSError, IOError): 
        continue 
       t = threading.Thread(target=self.handle_request, args=(c,)) 
       t.daemon = True 
       t.start() 
     except (KeyboardInterrupt, SystemExit): 
      pass 
    finally: 
     self.stop = 999 
     self.listener.close() 

अगर मैं एकाधिक अपलोड फोन, प्रबंधक कॉल के कुछ छोड़ देंगे: आप multiprocessing/managers.py के इस के अंदर देख सकते हैं?

नहीं, कोई भी कॉल नहीं छोड़ी जाएगी।

# do this wait for completion or do they perform this async 
print upload.upload(r"<path>", {...}, "some url") 
print upload.upload(r"<path>", {...}, "some url") 

upload.upload के लिए कॉल तुल्यकालिक हो जाएगा दोनों; वे UploadClass.upload तक वापस नहीं आ जाएंगे। हालांकि, यदि आपके पास upload.upload को समेकित एकाधिक स्क्रिप्ट/थ्रेड/प्रक्रियाएं थीं, तो प्रत्येक अद्वितीय कॉल Manager सर्वर प्रक्रिया में अपने स्वयं के धागे के साथ समवर्ती रूप से हो रही होगी।

और अपने सबसे सबसे महत्वपूर्ण प्रश्न:

इस ऐसा करने के लिए उचित तरीका है?

मैं नहीं कहूंगा, अगर मैं सही तरीके से प्रश्न समझता हूं। आप बस एक स्क्रिप्ट है, और फिर उस एक स्क्रिप्ट के अंदर दस multiprocessing.Process उदाहरणों अंडे पीडीएफ़ को लिखने के लिए है, तो आप सिर्फ एक और multiprocessing.Process अपलोड संभाल करने का उपयोग करना चाहिए:

def upload(self, q): 
    for payload in iter(q.get, None): # Keep getting from the queue until a None is found 
     filePath, params, destUrl = payload 
     # do stuff 

def write_pdf(pdf_file_info, q): 
    # write a pdf to disk here 
    q.put((filepath, params, destUrl)) # Send work to the uploader 
    # Move on with whatever comes next. 

if __name__ == '__main__': 
    pdf_queue = multiprocessing.Queue() 

    # Start uploader 
    upload_proc = multiprocessing.Process(upload, args=(pdf_queue,)) 
    upload_proc.start() 

    # Start pdf writers 
    procs = [] 
    for pdf in pdfs_to_write: 
     p = multiprocessing.Process(write_pdf, args=(pdf, pdf_queue)) 
     p.start() 
     p.append(procs) 

    # Wait for pdf writers and uploader to finish. 
    for p in procs: 
     p.join() 
    pdf_queue.put(None) # Sending None breaks the for loop inside upload 
    upload_proc.join() 

आप वास्तव में समवर्ती के साथ ठीक कर रहे हैं अपलोड, तो अलग upload प्रक्रिया बिल्कुल अलग करने की आवश्यकता नहीं है - बस पीडीएफ लेखन प्रक्रियाओं से सीधे अपलोड करें।

यह आपके प्रश्न से बताना मुश्किल है यदि यह वही है जो आप कर रहे हैं। एक बार जब आप स्पष्टीकरण देते हैं, तो मैं आपके अंतिम उपयोग-मामले में फिट होने के लिए इस अंतिम टुकड़े को समायोजित कर दूंगा।