Multiprocessing apply_async() funktioniert nicht auf Ubuntu

Question

Ich verwende diesen Code als CherryPy Web Service sowohl unter Mac OS X als auch unter Ubuntu 14.04. Unter Verwendung von multiprocessing auf Python3 möchte ich die statische Methode worker() in einer asynchronen Weise innerhalb einer Process Pool starten.

Der gleiche Code läuft einwandfrei auf Mac OS X, in Ubuntu 14.04 worker() läuft nicht. I.e. durch das Debuggen des Codes innerhalb der POST Methode, die ich bin in der Lage zu sehen, dass jede Zeile ausgeführt wird - von

reqid = str(uuid.uuid4()) 

zu

return handle_error(202, "Request ID: " + reqid) 

Beginnend mit dem gleichen Code in Ubuntu 14.04, läuft es nicht die worker() Methode , nicht einmal eine print() an der Spitze der Methode (die protokolliert werden würde).

Hier ist der entsprechende Code (I weggelassen nur die handle_error()-Methode):

import cherrypy 
import json 
from lib import get_parameters, handle_error 
from multiprocessing import Pool 
import os 
from pymatbridge import Matlab 
import requests 
import shutil 
import uuid 
from xml.etree import ElementTree 

class Schedule(object): 
    exposed = True 

    def __init__(self, mlab_path, pool): 
     self.mlab_path = mlab_path 
     self.pool = pool 

    def POST(self, *paths, **params): 

     if validate(cherrypy.request.headers): 

      try: 
       reqid = str(uuid.uuid4()) 
       path = os.path.join("results", reqid) 
       os.makedirs(path) 
       wargs = [(self.mlab_path, reqid)] 
       self.pool.apply_async(Schedule.worker, wargs) 

       return handle_error(202, "Request ID: " + reqid) 
      except: 
       return handle_error(500, "Internal Server Error") 
     else: 
      return handle_error(401, "Unauthorized") 

    #### this is not executed #### 
    @staticmethod 
    def worker(args): 

     mlab_path, reqid = args 
     mlab = Matlab(executable=mlab_path) 
     mlab.start() 

     mlab.run_code("cd mlab") 
     mlab.run_code("sched") 
     a = mlab.get_variable("a") 

     mlab.stop() 

     return reqid 

    #### 

# to start the Web Service 
if __name__ == "__main__": 

    # start Web Service with some configuration 
    global_conf = { 
      "global": { 
          "server.environment": "production", 
          "engine.autoreload.on": True, 
          "engine.autoreload.frequency": 5, 
          "server.socket_host": "0.0.0.0", 
          "log.screen": False, 
          "log.access_file": "site.log", 
          "log.error_file": "site.log", 
          "server.socket_port": 8084 
         } 
    } 
    cherrypy.config.update(global_conf) 
    conf = { 
     "/": { 
      "request.dispatch": cherrypy.dispatch.MethodDispatcher(), 
      "tools.encode.debug": True, 
      "request.show_tracebacks": False 
     } 
    } 

    pool = Pool(3) 

    cherrypy.tree.mount(Schedule('matlab', pool), "/sched", conf) 

    # activate signal handler 
    if hasattr(cherrypy.engine, "signal_handler"): 
     cherrypy.engine.signal_handler.subscribe() 

    # start serving pages 
    cherrypy.engine.start() 
    cherrypy.engine.block() 

Answer 1

Ihre Logik versteckt das Problem vor Ihnen. Die apply_async-Methode gibt ein AsyncResult-Objekt zurück, das als Handler für die asynchrone Aufgabe dient, die Sie gerade geplant haben. Wenn Sie das Ergebnis der geplanten Aufgabe ignorieren, sieht das Ganze so aus, als würde es "stillschweigend versagen".

Wenn Sie versuchen, die Ergebnisse von dieser Aufgabe zu erhalten, würden Sie das eigentliche Problem sehen.

handler = self.pool.apply_async(Schedule.worker, wargs) 
handler.get() 

... traceback here ... 
cPickle.PicklingError: Can't pickle <type 'function'>: attribute lookup __builtin__.function failed 

Kurz gesagt, müssen Sie die Argumente, die Sie an den Pool passieren gewährleisten Picklable sind.

Instanz- und Klassenmethoden sind pickbar, wenn das Objekt/die Klasse, zu der sie gehören, ebenfalls einfügbar ist. Statische Methoden sind nicht auswählbar, da sie die Assoziation mit dem Objekt selbst verlieren. Daher kann die Beizbibliothek sie nicht korrekt serialisieren.

Als allgemeine Linie, ist es besser zu vermeiden, die Planung auf multiprocessing.Pool etwas anderes als eine oberste Ebene definierten Funktionen.

Answer 2

Ich löste das Verfahren @staticmethod-@classmethod ändern. Jetzt läuft der Job innerhalb der ProcessPool. Ich fand Klassenmethoden in diesem Fall nützlicher, wie erklärt here.

Danke.

Answer 3

Zum Ausführen von Hintergrundaufgaben mit Cherrypy ist es besser, wenn Sie einen asynchronen Aufgabenwarteschlangenmanager wie Celery oder RQ verwenden. Diese Dienste sind sehr einfach zu installieren und auszuführen, Ihre Aufgaben werden in einem vollständig getrennten Prozess ausgeführt und wenn Sie skalieren müssen, weil Ihre Last zunimmt, wird es sehr einfach sein.

Sie haben ein einfaches Beispiel mit Cherrypy here.