Celery: उपप्रकारों को शुरू करने के लिए कार्य की अनुमति नहीं है

यह 3.0 और 3.1 के बीच नहीं बदला है, इसलिए मुझे यकीन नहीं है कि अब आपको यह त्रुटि क्यों मिलेगी और इससे पहले नहीं।

इस त्रुटि को कैसे पुन: प्रस्तुत किया जा सकता है।

app.py:

import multiprocessing
from celery import Celery

app = Celery(__name__, broker='amqp://192.168.33.40')
@app.task
def f():
    manager = multiprocessing.Manager()

sendtask.py:

import app

app.f.delay()

मैं निम्नलिखित कमांड का उपयोग करके कार्यकर्ता चलाता हूं: celery worker -A app.app -l debug ।

अजवाइन के साथ 3.0.24 कार्य सफल होता है:

[2013-12-02 20:43:56,454: INFO/MainProcess] Task app.f[bcaab028-dbec-43a8-9259-ff7c35ff13d0] 
succeeded in 0.0169339179993s: None

अजवाइन 3.1.5 के साथ यह नहीं है:

[2013-12-02 20:48:38,946: ERROR/MainProcess] Task app.f[c9f1cdd3-ae38-493e-b7c7-b9636ed473d0] 
raised exception: AssertionError('daemonic processes are not allowed to have children',)

मुद्दे की मेरी समझ निम्नलिखित है: celery.concurrency.prefork.TaskPool celery.concurrency.asynpool.AsynPool का उपयोग करता है; AsynPool billiard.pool.Pool से विरासत में मिला, जो डेमन कार्यकर्ता प्रक्रियाओं को जन्म देता है और AsynPool इस व्यवहार को ओवरराइड नहीं करता है। लेकिन आप सही कह रहे हैं, यह योजना 3.0 और 3.1 के बीच परिवर्तित नहीं होती है, इसलिए मैं भी भ्रमित हूँ :)

और ऐसा लगता है कि मैं उस समस्या से अकेला नहीं हूं: http://stackoverflow.com/questions/20149421/threads-in-celery-3-1-5

एक अंतर यह है कि कार्यकर्ता प्रक्रिया अब 'प्रक्रिया' का एक उपवर्ग है, जहां इससे पहले कि यह फ़ंक्शन तर्क का उपयोग करता है: Process(target=) , शायद इन दृष्टिकोणों के लिए डिफ़ॉल्ट मानों में अंतर है।

बहुप्रचलित और पुराने संस्करणों के बिलियर्ड सेट daemon=True :
https://github.com/celery/billiard/blob/2.7/billiard/pool.py#L904

और यह नवीनतम संस्करण में समान है:
https://github.com/celery/billiard/blob/3.3/billiard/pool.py#L1039

मुझे लगता है कि कार्य प्रक्रिया एक डेमॉन है जो कार्य कार्यान्वयन के लिए एक गंभीर सीमा प्रस्तुत करती है।
मैंने एक कार्य लिखा है जो सीपीयू-बाउंड संचालन को गति देने के लिए मल्टीप्रोसेसिंग का उपयोग करता है। जब मैं एक टर्मिनल में एक श्रमिक शुरू करता हूं तो सब कुछ ठीक काम करता है:

अजवाइन कार्यकर्ता --app = कार्य -Q wb -l जानकारी --concurrency = 1

लेकिन जब मैं एक कार्यकर्ता को शुरू करने के लिए अजवाइन की स्क्रिप्ट का उपयोग करता हूं, तो मुझे यह अपवाद मिलता है:
अभिकथन: डेमोनिक प्रक्रियाओं को बच्चे पैदा करने की अनुमति नहीं है

मुझे पता चला कि व्यवहार में क्या बदलाव आया है।
कार्य 3.0 और 3.1 दोनों में डेमॉन प्रक्रियाओं का उपयोग करके चलाए जाते हैं, लेकिन जब तक अजवाइन / बिलियार्ड @ 4c32d2e और https://github.com/celery/billiard/commit/c676b94aa4144b4b9b11ab31c82296a5d804909c9 multiprocessing मॉड्यूल की जानकारी नहीं होती है सबप्रोसेस बनाने की अनुमति दे रहा था।

मेरी समझ में, संस्करण 3.1 से पहले एक बग था (कार्यों को उपप्रकार बनाने की अनुमति दी गई थी, जिसके परिणामस्वरूप अनाथ राज्य हो सकता है) और अब यह बग तय हो गया है।

अजगर डेमॉन प्रक्रियाओं को कांटे की अनुमति नहीं देने का निर्णय मेरे लिए मनमाना लगता है। जब मैं इसके अच्छे विश्वास को पहचानता हूं, तो मुझे लगता है कि अगर मैं चुनता हूं तो मुझे इस व्यवहार पर पूर्ण नियंत्रण रखने में सक्षम होना चाहिए।

प्रति कार्य एक प्रक्रिया के लिए बाध्य होना मुझे एक गंभीर सीमा लगती है। विचार?

मुझे आश्चर्य है कि यह सीमा पहले स्थान पर क्यों है, एक चेतावनी जिसे मैं समझ सकता हूं लेकिन स्पष्ट रूप से इसे अस्वीकार करना मूर्खतापूर्ण लगता है जब आप अन्य साधनों का उपयोग करके प्रक्रियाओं को पूरी तरह से करने में सक्षम होते हैं।

@ मास्क , क्या डेमॉन फ्लैग के साथ अजवाइन कार्यकर्ता प्रक्रिया को शुरू करना गलत होगा? या इसे विन्यास योग्य बनाते हैं?

@ilyastam लगता है हम एक ही समय में टिप्पणी कर रहे थे

मैं सहमत हूं कि यह एक मनमाना सीमा की तरह लगता है, लेकिन काश मैं इसे पहले स्थान पर जोड़ने के पीछे तर्क को जानता था।

यह पॉज़िक्स सिस्टम में एक जाना-माना नुकसान है, लेकिन अभी भी इसकी अनुमति है। आप एक सिग्नल हैंडलर में बाल प्रक्रियाओं को साफ कर सकते हैं, हालांकि यह SIGKILL के खिलाफ आपकी रक्षा नहीं करता है।

मुझे लगता है कि हमें बिलियार्ड से सीमा को हटा देना चाहिए, भले ही यह बहु-व्यवहार व्यवहार से अलग हो। आप अभी भी subpocess मॉड्यूल का उपयोग करके या निम्न स्तर fork कॉल का उपयोग करके बाल प्रक्रियाएं बना सकते हैं, इसलिए बिजली उपयोगकर्ताओं को billiard.Process इंस्टेंसेस बनाने में सक्षम होना चाहिए।

@ ऑलस्टैम को उठाना बयान को हटाने में सक्षम होना चाहिए, प्रक्रियाओं को "गैर-डेमॉन" नहीं बनाना चाहिए

यही है, डेमन प्रक्रियाओं को बाल प्रक्रियाएं बनाने की अनुमति दी जाएगी, भले ही यह उन्हें वापस करने में सक्षम न हो,
जो वैसे भी पॉजिक्स कैसे काम करता है।

Btw, ध्यान दें कि यह raise , यह एक मुखर कथन है, जिसे हटा दिया जाएगा यदि अजगर को PYTHONOPTIMIZE envvar या -O तर्क के साथ शुरू किया जाए।

यह परिवर्तन सहित बिलियार्ड 3.3.0.11 PyPI पर है

@ का शुक्रिया। किसी भी विचार अजवाइन के किस संस्करण में यह सुधार दिखाई देगा?

multiprocessing प्रलेखन में स्पष्ट रूप से कहा गया है कि डेमन प्रक्रिया को उपप्रोसेस बनाने की अनुमति नहीं है और बताते हैं कि क्यों। मेरे अनुसार, यह assert स्टेटमेंट अधिक लगता है जैसे कि इसे raise (लोग अक्सर ऐसा करते हैं) के शॉर्टकट के रूप में यहाँ रखा गया था।

यह सीमा प्रलेखित है और मुझे नहीं लगता कि यह अजवाइन के लिए चुपचाप बंदर-पैच multiprocessing का एक अच्छा विचार है और इसे दूर ले जाएं। यह वास्तव में अप्रत्याशित और हानिकारक परिणाम पैदा कर सकता है।

मैं निम्नलिखित उदाहरण के बारे में सोच सकता हूं (यह थोड़ा विपरीत लग सकता है, हालांकि):

@app.task
def f():
    p = multiprocessing.Pool(3)
    p.map_async(time.sleep, [1000, 1000, 1000])

प्लेन पायथन फ़ंक्शन के रूप में चलाया जा रहा है, यह कोड सही ढंग से काम करता है। लेकिन एक अजवाइन कार्य के रूप में चलाया जा रहा है (अजवाइन संस्करण 3.0 का उपयोग करके। *), यह तीन उपप्रकार छोड़ देता है जो हमेशा के लिए लटक जाएगा; जब सेलेरी कार्यकर्ता बुझेगा, तो ये उपप्रकार अनाथ हो जाएंगे।

यह स्पष्ट नहीं करता है कि, यह सिर्फ यूनिक्स व्यवहार को बताता है, जिसे आप बच्चे-बच्चे की प्रक्रिया शुरू करते समय उम्मीद करेंगे। भले ही यह यूनिक्स में एक बदनाम सीमा है लेकिन यह लोगों को ऐसा करने से नहीं रोकता है। यह इससे अलग नहीं है
एक नई प्रक्रिया शुरू करने के लिए subprocess.Popen प्रक्रिया शुरू करना, या fork() कॉल करना। तो यह अवैध क्यों होना चाहिए?

अपना उदाहरण करने का तरीका:

from billiard import Pool
from multiprocessing.util import Finalize

_finalizers = []

@app.task
def f():
    p = billiard.Pool(3)
    _finalizers.append(Finalize(p, p.terminate))
   try:
       p.map_async(time.sleep, [1000, 1000, 1000])
       p.close()
       p.join()
   finally:
       p.terminate()

(-9) को मारने के लिए आपको बच्चे की प्रक्रियाओं को भी मारना होगा, लेकिन यह कुछ ऐसा है जो आपके पास होगा
सभी यूनिक्स प्रक्रियाओं पर विचार करने के लिए।

ऐसा नहीं है कि मैं हर कार्य के लिए एक पूल बनाने की वकालत करता हूं, लेकिन मैं यह नहीं देखता कि उपयोगकर्ता, जो जानते हैं कि वे क्या कर रहे हैं
किसी कार्य से प्रक्रिया प्रारंभ करने की अनुमति नहीं दी जानी चाहिए।

इसके अलावा, हम कुछ भी नहीं करते हैं यह केवल बिलियर्ड में बदलाव है।

इसके अलावा, हम कुछ भी नहीं करते हैं यह केवल बिलियर्ड में बदलाव है।

"मंकी पैचिंग" से मेरा तात्पर्य इस असाइनमेंट से है, जो multiprocessing._current_process को billiard.process.Process आवृत्ति के साथ बदलता है: https://github.com/celery/billiard/blob/master/billiard-process.py # एल 53।

मैं इस बात से सहमत हूं कि बाल-बाल प्रक्रियाओं को शुरू करने में कुछ भी गलत नहीं है अगर उन्हें सही तरीके से नियंत्रित किया जाता है (जैसे आपके उदाहरण में)। मेरा कहना है कि multiprocessing को इस तरह नहीं लिखा गया है और हमें इसे अनदेखा नहीं करना चाहिए _ कार्यान्वयन / सीमाएँ।

@aromanovich इसे किसी अन्य तरीके से नहीं लिखा जा सकता है, यह एक प्रकार का

यह _current_process सेट करता है ताकि लॉगिंग मॉड्यूल processName स्वरूप चर काम करता है, और बिलियर्ड प्रक्रिया ऑब्जेक्ट में बहुप्रोसेसर प्रक्रिया ऑब्जेक्ट के समान API है ताकि वर्तमान प्रक्रिया को सेट करना सुरक्षित हो।

और btw, आपको सीमा को हटाने के लिए बिलियर्ड का उपयोग करना होगा, मल्टीप्रोसेसिंग का उपयोग करना अभी भी अपवाद को बढ़ाएगा।

इस दृष्टिकोण का उपयोग करके इस समस्या को भी ठीक कर सकता है:
http://stackoverflow.com/questions/6974695/python-process-pool-non-daemonic
जो उपयोगकर्ताओं को इस समस्या से बचने के लिए मल्टीप्रोसेसिंग मॉड्यूल का उपयोग जारी रखने की अनुमति देगा:
https://github.com/celery/billiard/issues/99

मुझे यह त्रुटि तब होती है जब एक अजवाइन कार्य के भीतर से @ फैब्रिक कार्य को कॉल किया

@celery.task
def dostuff():
   execute(fabfile.push_settings, sid=site['sid'])

<strong i="7">@parallel</strong>
@roles(environment)
def push_settings(sid):
  #do stuff

@frodopwns ENV का उपयोग करते हैं
निर्यात PYTHONOPTIMIZE = 1
इस जोर को हटाने के लिए। आपको सभी चीजों को संभालने की आवश्यकता है।

@xiaods मुझे लगता है कि मैंने इस मुद्दे को कुछ इस तरह से हल किया है:

@worker_process_init.connect
def configure_workers(sender=None, conf=None, **kwargs):
    Crypto.Random.atfork()

संकट

मेरा एक कार्य है जो कुछ डेटा की गणना करता है और उस डेटा के आधार पर भविष्यवाणियां करने के लिए एक डरावना-सीखा क्लासिफायर लोड करता है। जब मैं अपने आप से कार्य चलाता हूं, तो सब कुछ ठीक है, लेकिन जब मैं इसे सेलेरी का उपयोग करके चलाता हूं, तो मुझे एक त्रुटि मिलती है जब कार्य अचार वाले क्लासिफायर को लोड करने का प्रयास करता है:

[2015-07-17 21:23:51,299: ERROR/MainProcess] Task app.f[329d0da4-2e0e-4e1f-8148-d64f47750b1f] raised unexpected: AttributeError("'Worker' object has no attribute '_config'",)
Traceback (most recent call last):
  File "/home/username/anaconda3/lib/python3.4/site-packages/celery/app/trace.py", line 240, in trace_task
    R = retval = fun(*args, **kwargs)
  File "/home/username/anaconda3/lib/python3.4/site-packages/celery/app/trace.py", line 438, in __protected_call__
    return self.run(*args, **kwargs)
  File "/home/username/working/playground/celery/app.py", line 11, in f
    clf = pickle.load(open('clf.pickle', 'rb'))
  File "/home/username/anaconda3/lib/python3.4/site-packages/sklearn/ensemble/__init__.py", line 6, in <module>
    from .base import BaseEnsemble
  File "/home/username/anaconda3/lib/python3.4/site-packages/sklearn/ensemble/base.py", line 13, in <module>
    from ..externals.joblib import cpu_count
  File "/home/username/anaconda3/lib/python3.4/site-packages/sklearn/externals/joblib/__init__.py", line 112, in <module>
    from .parallel import Parallel
  File "/home/username/anaconda3/lib/python3.4/site-packages/sklearn/externals/joblib/parallel.py", line 23, in <module>
    from ._multiprocessing_helpers import mp
  File "/home/username/anaconda3/lib/python3.4/site-packages/sklearn/externals/joblib/_multiprocessing_helpers.py", line 25, in <module>
    _sem = mp.Semaphore()
  File "/home/username/anaconda3/lib/python3.4/multiprocessing/context.py", line 81, in Semaphore
    return Semaphore(value, ctx=self.get_context())
  File "/home/username/anaconda3/lib/python3.4/multiprocessing/synchronize.py", line 127, in __init__
    SemLock.__init__(self, SEMAPHORE, value, SEM_VALUE_MAX, ctx=ctx)
  File "/home/username/anaconda3/lib/python3.4/multiprocessing/synchronize.py", line 59, in __init__
    kind, value, maxvalue, self._make_name(),
  File "/home/username/anaconda3/lib/python3.4/multiprocessing/synchronize.py", line 117, in _make_name
    return '%s-%s' % (process.current_process()._config['semprefix'],
AttributeError: 'Worker' object has no attribute '_config'

प्रजनन करना

एक खाली क्लासिफ़ायर बनाएं और इसे अचार के रूप में सहेजें:

import pickle
from sklearn.ensemble import GradientBoostingClassifier
clf = GradientBoostingClassifier()
pickle.dump(clf, open('clf.pickle', 'wb'))

एक साधारण ऐप बनाएं ( app.py ):

import pickle
import sklearn
from celery import Celery

app = Celery(__name__, broker='amqp://localhost//')

@app.task
def f():
    print('hello')
    clf = pickle.load(open('clf.pickle', 'rb'))
    print(clf)

अजवाइन कार्यकर्ता शुरू करें:

celery -A app worker --loglevel=debug

एप्लिकेशन चलाएँ:

python -c "from app import f; f.delay()"

त्रुटि संदेश:

...
AttributeError: 'Worker' object has no attribute '_config'

समाधान

मुझे लगता है कि उप-प्रक्रियाओं को शुरू करने के लिए कार्यों को अनुमति देने के लिए "मंकीकैच" अजवाइन का विकल्प होना चाहिए, खासकर अगर अतीत में ऐसी "सुविधा" मौजूद थी। अभी, जब लोग इस समस्या का सामना करते हैं, तो लोग बस दूसरे ढांचे में चले जाते हैं: http://stackoverflow.com/questions/27904162/use-multiprocessing-pool-from-celery-task-raises-exception। यहाँ इस त्रुटि का एक और उदाहरण है: http://stackoverflow.com/questions/22674950/python-multiprocessing-job-to-celery-task-but-attributeerror।

इस मुद्दे को फिर से खोला जाना चाहिए ...

मैं बस एक ही समस्या में भाग गया। मैं अपने कार्यकर्ताओं में से एक के अंदर nltk का उपयोग कर रहा हूं, जो scikit-learn आयात करता है जो उसी त्रुटि की ओर जाता है जो @ostrokach ने दिखाया है।

ऐसा लगता है कि मैं निम्नलिखित कोड के साथ इसके आसपास काम करने में सक्षम हूं:

from celery.signals import worker_process_init

@worker_process_init.connect
def fix_multiprocessing(**kwargs):
    from multiprocessing import current_process
    try:
        current_process()._config
    except AttributeError:
        current_process()._config = {'semprefix': '/mp'}

यह स्पष्ट रूप से एक बहुत ही क्रूड हैक है और मुझे नहीं पता कि क्या होगा यदि मैं वास्तव में मल्टीप्रोसेसिंग का उपयोग करूंगा (बिल्ली मुझे भी नहीं पता है कि semprefix है) लेकिन यह scikit-learn बनाने के लिए पर्याप्त है

मैं इसे अन्य लोगों के लिए यहां छोड़ रहा हूं, जो इस समस्या के ठीक होने तक उसी समस्या पर ठोकर खाते हैं।

क्या यह अजगर 3 पर बिलियर्ड के साथ किसी प्रकार की असंगति हो सकती है? या यह अजगर 2 पर भी प्रजनन योग्य है?

क्या अजवाइन प्रक्रियाओं का मूल मुद्दा अभी भी एक उपप्रकार बनाने में सक्षम नहीं है? टिप्पणियों के माध्यम से पीछे देखते हुए, यह 3.3 संस्करण के लिए अजवाइन / बिलियर्ड @ e6bb0f7 के साथ तय किया गया था। हालाँकि बाद के एक कमेटी (सेलेरी / बिलियार्ड @ c7eedbd0ee1498e76d4fa1affac5b1a275660ee7) ने प्रारंभ विधि में 3.4 के समान बहुत ही जोरदार बयान दिया। मेरे लिए कोई मुद्दा नहीं है जब से मैं 3.3 पर हूं, लेकिन सिर्फ यह इंगित करना चाहता था कि क्या यह भविष्य में समस्याएं पैदा कर सकता है।

@martinth धन्यवाद, यह हैक मेरे लिए भी काम करता है!

@xiaods धन्यवाद! आपका समाधान मेरे लिए काम करता है! धन्यवाद!

@gilinson यह अभी भी एक मुद्दा है और PYTHONOPTIMIZE = 1 अभी भी "थोदा फिक्स" इसे निर्यात करता है।
बस एक ही समस्या में भाग गया, सेलेरी कार्य में ansible playbook चलाने की कोशिश कर रहा है

@ स्मार्टथिन हैक के लिए धन्यवाद! मैं उसी मुद्दे पर चल रहा हूं:

• अजगर 3.4.3
• अजवाइन == 3.1.18
• scikit-learn == 0.17

@martinth का हैक मेरे लिए काम नहीं करता है, कुछ कम्प्यूटेशन को तेज करने के लिए मल्टीप्रोसेसिंग का उपयोग करने की कोशिश में यह भाग गया। इसके बजाय थ्रेडिंग मॉड्यूल का उपयोग किया और यह अभी भी मेरे प्रसंस्करण को तोड़ने के दौरान मेरे लिए इस त्रुटि को दूर करने के लिए लगता है।

थ्रेड-आधारित मल्टीप्रोसेसिंग का उपयोग करना।

from multiprocessing.dummy import Pool

यह त्रुटि अभी भी अजगर 2.7.5 में हो रही है। मुझे यकीन नहीं है कि अगर इसे कभी भी संबोधित करने का इरादा है, लेकिन यह अजवाइन के साथ नमक-एसएचएस का उपयोग नहीं करता है।

इसे बंद करना, क्योंकि हमारे पास इस कार्य को पूरा करने के लिए संसाधन नहीं हैं।

संभावित स्थिति"

मेरे पास ऐसा काम था जो धागे बनाने की कोशिश कर रहा था और यह विफल हो जाएगा। मैं इसके द्वारा काम करने में कामयाब रहा: एक बैश स्क्रिप्ट के लिए धन्यवाद, जो खुद एक अजगर दुभाषिया की ओर इशारा करता है, जो एक ही सटीक कोड करता है (और इसलिए धागे बना सकता है, जो मेरे उपयोग के मामले के लिए महत्वपूर्ण था)।

मुझे समझ नहीं आया कि टिकट क्यों बंद है। यदि आपके पास इसके लिए संसाधन नहीं हैं, तो आप इस बारे में टिप्पणी कर सकते हैं, लेकिन यह टिकट को बंद नहीं करता है। तुम बस बग को छिपा रहे हो।

जो प्राथमिकता और गंभीरता दोनों के लिए "क्रिटिकल" लेबल वाले टिकट के लिए विशेष रूप से खराब है।

@orzel +1।
प्राथमिकता: महत्वपूर्ण
गंभीरता: महत्वपूर्ण
इसे बंद करना, क्योंकि हमारे पास इस कार्य को पूरा करने के लिए संसाधन नहीं हैं।

वह एक मजाक है। यदि आपके पास अभी संसाधन नहीं हैं - तो अब इसे ठीक न करें। इसे ठीक करें जब आपके पास संसाधन होंगे। टिकट बंद करने से समस्या दूर नहीं होगी

@orzel @Templarrr मैंने इस टिकट को क्रिटिकल के रूप में लेबल किया है इसलिए @ask यहां दोष नहीं है।
आप इस बारे में दुखी हो सकते हैं, लेकिन विरोध करने से मदद नहीं मिलेगी।
हमें अपने बैकलॉग को इस बात पर आधारित करने की आवश्यकता है कि क्या कार्रवाई योग्य है और क्या नहीं है और वर्तमान में यह नहीं है।
यह बनाने के लिए एक कठिन कॉल है लेकिन किसी को इसे बनाना है।
यदि यह समस्या आपके रास्ते में है, तो इसे ठीक करने का प्रयास करें। मैं वादा करता हूं कि अगर फिक्स सही है और मेरे पास उपयुक्त परीक्षण हैं तो मैं इसे मर्ज कर दूंगा।

@ डेडब्रो
आपने गलत समझा। दो बार।
हमारी चिंता यह नहीं है कि आपके पास संसाधन नहीं हैं (यह पूरी तरह से समझ में आता है, और दुख की बात है, मुफ्त सॉफ्टवेयर में एक बहुत ही सामान्य मामला है)। हमारी चिंता यह है कि इसकी वजह से टिकट बंद है, यह नहीं है कि टिकट कैसे काम करता है।
हम 'दुखी' नहीं हैं, हम स्तब्ध हैं।

मैं भी इसे बंद करने से पूरी तरह असहमत हूं।

मुझे लगता है कि हम सभी सहमत हो सकते हैं कि यह _is_ वास्तव में एक बग है। और जब यह वास्तव में दुःखद है कि एक पर्याप्त संसाधन नहीं हैं, तो _definite_ बग इसकी मदद नहीं करेगा। आप संभवतः यह नहीं जान सकते हैं कि शायद कल कोई व्यक्ति आता है और सोचता है "सेलरी में कुछ कीड़े ठीक करने देता है" बस खुले मुद्दों के माध्यम से देखने के लिए और सोचता है "ठीक है, यहाँ कोई दिलचस्प काम नहीं है ... चलो काम करते हैं इसके बजाय _OtherProject_ पर "।
इसके अतिरिक्त, इस समस्या को बंद करने से इसे ढूंढना कठिन हो जाएगा। मुझे नहीं पता कि आप गितुब का उपयोग कैसे करते हैं, लेकिन जब मुझे एक संभावित समस्या का पता चलता है तो मैं पहली बार खुले मुद्दे के लिए समस्या ट्रैकर खोजता हूं। आम तौर पर बहुत चर्चा होती है और कभी भी कोई वर्कअराउंड नहीं होता है (जैसे इस मामले में) मैं अभी के लिए उपयोग कर सकता हूं। केवल अगर मुझे _really_ हताश हो जाता है तो मैं बंद मुद्दों को देखना शुरू करता हूं।

यह "बैकलॉग ग्रूमिंग" नहीं है यह नंबर ट्विकिंग है। अगर मैं I _do_ का उपयोग करने के लिए चीजों को देखता हूं तो खुले अंक की गिनती को देखें लेकिन मैं हमेशा स्टार की गिनती (जो कि अजवाइन के लिए बहुत अधिक है) को देखता हूं। मैं समझता हूं कि सार्वजनिक अपील के लिए कम बग गिनती के लिए वांछनीय है, लेकिन अपने खुद के लिए भी। ईमानदारी से, मैं समझता हूं कि "250 खुले मुद्दे" देखना एक अच्छी संख्या नहीं है और भारी लगता है।

यदि आपके पास अगले महीने (या यहां तक ​​कि वर्ष) पर काम करने के लिए श्रमशक्ति नहीं है, तो यह ठीक है_। बस पास नहीं है। एक करीबी तभी होना चाहिए जब समस्या या तो हो या यह स्पष्ट रूप से स्पष्ट है कि यह _never_ किया जाएगा। दोनों ही यहां नहीं हैं।

बस "क्रिटिकल" झंडे को हटा दें और किसी भी चीज़ के लिए "स्थगित" ध्वज जोड़ें, जो अब संभाला नहीं जा सकता है लेकिन संसाधन _are_ उपलब्ध होने पर उसे संभाला जाना चाहिए।

मुझे यकीन नहीं है कि हम वास्तव में इस मुद्दे को ठीक कर सकते हैं। हम यह नहीं बदल सकते कि यूनिक्स कैसे काम करता है लेकिन प्रतिबंध हटाने के लिए हम एक पैच अपस्ट्रीम जमा कर सकते हैं?

शायद लिनक्स में मंच विशिष्ट समाधान हैं, लेकिन उस पर शोध करना होगा। इसे ठीक करने के लिए किसी के पास प्रोत्साहन के बिना 2 साल के लिए खुला है, इसलिए यह निकट की सुविधा में तय होने की संभावना नहीं है।

मैंने 200+ मुद्दों को बंद कर दिया और 30k से अधिक ईमेलों को अच्छी तरह से पढ़ा। मैं पूरी तरह से यह उम्मीद करता हूं, लेकिन फिर यह अच्छा होगा यदि हम किसी समाधान में योगदान कर सकते हैं, जैसे कि दोष का दस्तावेजीकरण करने में मदद करना यदि वह एकमात्र ज्ञात विकल्प है।

हम काम के साथ बह गए हैं, एक बड़ी परियोजना को बिना संसाधनों के संचालित करने की कोशिश कर रहे हैं। हम मुद्दों को ट्राई करने या यह पता लगाने में असमर्थ हैं कि कौन से मुद्दे पहले से तय किए गए हैं।

चलो ठीक है। लेकिन क्या यह तथ्य है कि "यदि आप एक अजवाइन कार्यकर्ता के लिए कोड लिखते हैं तो आप मल्टीप्रोसेसिंग का उपयोग नहीं कर सकते हैं" कम से कम प्रलेखित किया जाए? मेरा मतलब है ... हमेशा ऐसे लोग होंगे जो इसे नहीं पढ़ते हैं, लेकिन कम से कम आप इसे इंगित कर सकते हैं और कह सकते हैं "देखें, यह प्रलेखित है। हम इसे बदल नहीं सकते हैं। इससे निपटें।"

मेरी टूडू सूची विशाल है, आप दस्तावेज़ को सीधे अब github पर संपादित कर सकते हैं, इसलिए इन जैसे परिवर्तनों में योगदान देना वास्तव में आसान है: (

मैं मुद्दों को छिपाने के लिए ऐसा नहीं करता हूं, मैं लोगों को कार्रवाई में कोड़ा मारने के लिए ऐसा कर रहा हूं क्योंकि मैं इसे बेहतर देखना चाहता हूं।

@ मास्क क्या हम django में अजवाइन का उपयोग करके कार्य के अंदर मल्टीप्रोसेसिंग लागू कर सकते हैं?
क्या ऐसा करने का कोई विकल्प है?

@abhisheksachan आपको इस तरह के सवाल को पोस्ट करने से पहले यह सब पढ़ना चाहिए

@abhisheksachan मैंने इसे कुछ वर्षों में आज़माया नहीं है, लेकिन मैंने इसे https://pypi.python.org/pypi/billiard का उपयोग करके काम करते हुए पा लिया था क्योंकि यह सबप्रोसेस के डेमनीज़ेशन की अनुमति देता है।

उदाहरण के लिए, आपको 'बहुप्रचार' से आयात को प्रतिस्थापित करना होगा, उदाहरण के लिए:

from multiprocessing import Process

->

from billiard import Process

हमारे लिए मल्टीप्रोसेसिंग सीमा को अक्षम करने का कोई तरीका नहीं है, लेकिन हमारा तर्क है कि वैसे भी कोई सीमा नहीं होनी चाहिए ताकि हमारा मल्टीप्रोसेसिंग कांटा इसे अनुमति दे सके।

किसी के लिए, जो मुझे पसंद करते हैं, एक पंक्तिबद्ध प्रणाली को विकसित करने में निवेश किया _ _FORE_ उस सीमा के बारे में पता लगाने और एक अलग समाधान की आवश्यकता है जब तक कि वे अधिक उपयोग करने योग्य खरगोश क्यूएम पायथन रैपर में माइग्रेट नहीं कर सकते, मैं एक बाहरी उपप्रकार को कॉल करके इस मुद्दे के आसपास काम करने में कामयाब रहा। कांटा खुद साफ। यह कांटा हुआ प्रक्रिया अब अजवाइन सैंडबॉक्स के बाहर है और चीजों को काम करना चाहिए।

ओपी उदाहरण में, प्रतिस्थापित करें:

app = Celery(__name__, broker='amqp://192.168.33.40') 
@app.task
def f():
    manager = multiprocessing.Manager()

साथ से:

app = Celery(__name__, broker='amqp://192.168.33.40')
@app.task
def f():
    process = subprocess.Popen(["program"]) # or the newer post 3.5 run version
    process.wait()
    # analyze exit code

और "कार्यक्रम" (POSIX यूनिक्स / लिनक्स मंच के तहत) की तरह दिखेगा

import os

def main():
      manager = multiprocessing.Manager()

# this is equivalent to "(cmd )&" under bash
pid = os.fork()
if pid == 0:
    cpid = os.fork()
    if cpid == 0:
        main()
    else:
        exit(0)
else:
    os.wait(pid)

इस बात को ध्यान में रखें कि सीपीयू प्रबंधन, अजवाइन के दायरे से बच जाता है जो कि अजवाइन का उपयोग करने के विचार के खिलाफ जाता है, लेकिन यह देखते हुए कि आप मल्टीप्रोसेसिंग का उपयोग करने जा रहे हैं, आप शायद वैसे भी अजवाइन से बाहर सीपीयू उपयोग को संभालना चाहते हैं।

बहुत कम से कम उस सीमा को प्रलेखित किया जाना चाहिए। मैंने डॉक में चारों ओर देखा और नहीं मिला।

फिर से, दस्तावेज़ परिवर्तनों के साथ एक पुल अनुरोध सबमिट करने के लिए स्वतंत्र महसूस करें।

पायथॉन 3.5.2, सेलेरी 4.0.0 और बिलियार्ड 3.5.0 पर @ स्मार्टमिंट की टिप्पणी के बाद , उसका समाधान काम नहीं किया, क्योंकि प्रक्रिया को बहुउद्देशीय किया जा रहा है, जिसे जांचा जा रहा है।

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

@worker_process_init.connect
def fix_multiprocessing(**kwargs):
    # don't be a daemon, so we can create new subprocesses
    from multiprocessing import current_process
    current_process().daemon = False

उस ने कहा, IMHO सेलेरी को कॉन्फ़िगर करने के लिए एक प्रलेखित विकल्प जोड़ना चाहिए कि क्या यह श्रमिकों को बहरों के रूप में शुरू करता है। ध्यान दें कि मैं k8 फली में अजवाइन का उपयोग कर रहा हूँ इसलिए अजवाइन को celery worker का उपयोग करते हुए अग्रभूमि प्रक्रिया के रूप में शुरू किया जाता है, और मुझे वास्तव में विमुद्रीकृत श्रमिकों की आवश्यकता नहीं

@miraculixx इस सुझाव के साथ समस्या यह है कि हमारे पास हैंडल करने के लिए अधिक विफल मोड और पते के लिए अधिक समस्याएँ

हालांकि मल्टीप्रोसेसिंग का उपयोग करना प्रीफ़ॉर्क पूल के साथ संयोजन में विफल रहता है, यह एकल पूल का उपयोग करते समय काम करता है। इसलिए मुझे लगता है कि प्रीफ़ॉर्क पूल में एक से अधिक बच्चों के साथ एकल पूल के साथ कई अजवाइन श्रमिकों को फैलाने के लिए एक वर्कअराउंड होगा। क्या यह ध्वनि वैध है? बेशक, कुछ विकल्प जैसे कि अधिकतम-मेम-प्रति-बच्चा काम नहीं करेगा।

मुझे लगता है कि यह मूल रूप से एक एप्लिकेशन डिज़ाइन समस्या है। यह daemonic processes are not allowed to have children सामना करने वाला एक विशेष दर्द है, क्योंकि आप जानते हैं, आप एक बिंदु पर पहुंच गए जब आपको पूरे एप्लिकेशन को नया स्वरूप देना होगा। लेकिन यह ओएस स्तर की सीमा है, आप इसे गंभीर दुष्प्रभावों के बिना नहीं रोक सकते। डेमोनिक प्रक्रियाओं में सी में बच्चे भी नहीं हो सकते हैं। यह पायथन-विशिष्ट सामान नहीं है। थ्रेड बनाम प्रक्रिया प्रदर्शन के बारे में एक बहस हुआ करती थी, और जैसा कि निष्कर्ष निकला कि उनमें से कोई भी दूसरे की तुलना में बेहतर या बदतर नहीं है।

मैं दो विकल्पों का सुझाव देता हूं (और सामान्य रूप से बात कर रहा हूं, यहां अजवाइन के बारे में नहीं)

• स्वतंत्र प्रक्रिया को गति देने के लिए subprocess.Popen का उपयोग करें, जिसमें बच्चे हो सकते हैं और अंतर-प्रक्रिया संचार के लिए UNIX सॉकेट्स का उपयोग कर सकते हैं
• क्या यह वास्तव में थ्रेड प्रक्रिया के द्वारा थ्रेड के लिए नेक्ससरी है और आपकी मुख्य प्रक्रिया नहीं है?

इसके लायक होने के लिए, मेरा उपयोग मामला वापस तो यह था कि मैं एक लंबे समय तक चलने वाले उपप्रकार को लॉन्च करना चाहता था जो अक्सर गैर-तुच्छ (और गैर-सुरक्षा संवेदी) इनपुट मुद्दों के कारण जल्दी से दुर्घटनाग्रस्त हो जाएगा। तो यह विचार कम से कम यह सुनिश्चित करने के लिए था कि प्रक्रिया सफलतापूर्वक शुरू हुई।

यह लंबी अवधि में विभिन्न कारणों से खराब डिजाइन बन गया, इसलिए नए आर्किटेक्चर ने स्वाभाविक रूप से एस्किस सेलेरी श्रमिकों के "प्राकृतिक" उपयोग के लिए वापस कर दिया। इसलिए मैं सवाल करने के विचार से सहमत हूं कि यदि फोर्किंग वास्तव में आवश्यक है; कार्य _is_ कांटा।

इसके लायक होने के लिए, मेरा उपयोग मामला स्किटिट-लर्न प्रक्रियाओं को लॉन्च करने के लिए था जो मल्टीप्रोसेसिंग (जॉबलिब के माध्यम से) का उपयोग करता है। मैंने तब से जॉबलीब के लिए एक अजवाइन बैकएंड विकसित किया है जिसका मतलब है कि अजवाइन का उपयोग करके समानांतर प्रक्रियाएं शुरू होती हैं और मेरी उपरोक्त हैक की अब आवश्यकता नहीं है। यह POC चरण में है, जो अभी तक प्राइम-टाइम के लिए तैयार नहीं है।

@miraculixx क्या आपने इसे कहीं होस्ट किया है? मैं एक नज़र रखना और / या इसे आज़माना चाहता / चाहती हूँ। मैं आप के रूप में एक ही मुद्दे में चल रहा हूं - स्केलेर स्पॉनिंग सबप्रोसेस - और मैंने मूल रूप से सेलेरी पर छोड़ दिया है।

@pgeez यदि आप स्केलेर में उपप्रकारों का उपयोग करने के बारे में परवाह नहीं करते हैं, तो आप पर्यावरण चर JOBLIB_MULTIPROCESSING = 0 सेट कर सकते हैं। Https://github.com/scikit-learn/scikit-learn/blob/0.18.X/sklearn/externals/joblib/_multiprocessing_helpers.py

@jennaliu विचार के लिए धन्यवाद, लेकिन @miraculixx की तरह, मुझे मल्टीप्रोसेसिंग सक्षम की आवश्यकता है।

क्या आप लोगों ने अजवाइन की डेमॉन प्रक्रिया से बच्चों को निकालने के लिए पुरानी यूनिक्स डबल-फोर्क चाल की कोशिश की है?

क्या आपने इस सूत्र का शीर्षक पढ़ा है?!?

@sebastroy स्पष्ट रूप से, मैं वर्षों से इस धागे का अनुसरण कर रहा हूं। मैंने अभी डबल कांटा खोजा है, लेकिन मैं देख रहा हूं कि मेरा भ्रम यह सोच रहा था कि डेमन फोर्क अजवाइन से मारे जा रहे थे, न कि यह कि उन्हें सीधे रोका जा रहा था।

पकड़ लिया। मेरे पिछले जीवन में हाँ, मैं सी का उपयोग कर रहा था इसलिए यह रोटी और मक्खन की तरह था।

मैं जिस वर्कअराउंड का उपयोग कर रहा हूं वह सबप्रोसेस है। जो ठीक काम करता है लेकिन फिर आपको कुछ तर्क को फिर से लागू करने की आवश्यकता है (और प्रोग्राम का एक शेल संस्करण बनाएं) जो कि अजवाइन पहले स्थान पर होना चाहिए। लेकिन मैंने शीर्ष स्तरीय एपीआई कार्यान्वयन के व्यवहार को बदलकर इसे ठीक किया। मुझे लगता है कि यह अजवाइन के उद्देश्य के साथ अधिक संरेखित है। कुछ तर्क सरल करें जो निम्न स्तर का हो।

सौभाग्य से find मुझे यह मुद्दा तब मिला, जब मैं सेलेरी के कार्य में अन्सिबल प्लेबुक चलाने की कोशिश कर रहा हूं।
@Martinth द्वारा प्रदान की गई विधि ने मेरे लिए काम नहीं किया है। मैं current_process()._config प्रिंट करता हूं और प्राप्त करता हूं
{'authkey': b"y&e\x8d'\xcb\xd4\r\xd2\x86\x06\xe7\x9e\x14\xaf \xbc\xc4\x95\xa5G\xec&[i\x19\xf3G-\x06\xac\x19", 'semprefix': '/mp', 'daemon': True} ।
फिर मैं फ़ील्ड daemon से False पुन: असाइन करता हूं, और यह काम करता है।

क्या कार्य में मल्टीप्रोसेस को चलाने की अनुमति देने के लिए कुछ समाधान या अन्य कार्यान्वयन है?

@HeartUnchange : हाल ही में हम एक बड़ी डेटा परियोजना पर काम कर रहे हैं, कि हम वितरित घटक के रूप में अजवाइन का उपयोग करना चाहते हैं। और आपके गाइड के साथ, हम समस्या को हल करने के लिए बहुत भाग्यशाली हैं। कार्य कॉन्फ़िगरेशन देखें:

     @app.task
    def handleBigZipfile(filename,nid):
    current_process()._config['daemon'] = False
    logger.info('{} begin handle!'.format(filename))
    handleAll(filename,nid)
     logger.info('{} is done!'.format(filename))

समाधान ठीक है! हम 2017.1 पर परियोजना शुरू करते हैं और अब प्रोटोटाइप समाप्त हो गया है! नो महीने हो गए! मैं आपको धन्यवाद देता हूं! और मेरा धन्यवाद अभिव्यक्ति से परे है!
क्या आप इस बारे में अधिक वर्णन कर सकते हैं कि आप समस्या का पता कैसे लगाते हैं! हम यह जानने के लिए उत्सुक हैं!

नमस्ते ,

मेरे पास एक सुंदर मानक सेट-अप है: Django + Rabbitmq + अजवाइन-4.0.2 + अजगर-2.7 + सेंटोस -7

मैं अजवाइन में मानक अजगर मल्टीप्रोसेसिंग मॉड्यूल का उपयोग करके एक प्रक्रिया को स्पॉन करने की कोशिश कर रहा हूं।

डेमन प्रक्रियाओं को बाल प्रक्रियाएं बनाने की अनुमति नहीं है और परिणामस्वरूप, मल्टीप्रोसेसिंग पैकेज का उपयोग करने वाले कार्य काम नहीं कर रहे हैं:
कमांड चलाया जाता था: अजवाइन कार्यकर्ता -B -A celery_task -l डिबग
ट्रेसेबैक लॉग्स:

[2017-09-26 23:27:08,838: WARNING/PoolWorker-2] ERROR
[2017-09-26 23:27:08,839: WARNING/PoolWorker-2] Traceback (most recent call last):
[2017-09-26 23:27:08,839: WARNING/PoolWorker-2] File "/home/induser/config.py", line 612, in main
[2017-09-26 23:27:08,840: WARNING/PoolWorker-2] mylog_process = mp.Process(target=test_logger_process, args=(myqueue,))
[2017-09-26 23:27:08,840: WARNING/PoolWorker-2] File "/usr/lib64/python2.7/multiprocessing/process.py", line 98, in __init__
[2017-09-26 23:27:08,841: WARNING/PoolWorker-2] self._authkey = _current_process._authkey
[2017-09-26 23:27:08,841: WARNING/PoolWorker-2] AttributeError: 'Process' object has no attribute '_authkey'

इस प्रक्रिया के नहीं होने का क्या कारण हो सकता है?
यहाँ कोड है:

import multiprocessing as mp
from celery.schedules import crontab
from celery.decorators import periodic_task

@periodic_task(run_every=crontab(minute='*/1'), name='test_process_celery')
def main():
data = config_read()
try:
    myqueue = mp.Queue(-1)
    mylog_process = mp.Process(target=test_logger_process, args=(myqueue,))
    mylog_process.start()
    . . .
    . . .
except Exception as e:
    raise
finally:
    mylog_process.join()

धन्यवाद।

यदि यह अभी भी समस्या है तो मास्टर और रिपोर्ट करने का प्रयास करें

इसमें अभी भी त्रुटि है। मैंने इसके साथ एक उपप्रकार का उपयोग करने की कोशिश की:

from multiprocessing import Process, Value
import ctypes

[...]
        result = Value('i', 0)
        text = Value(ctypes.c_char_p, fail_string.encode())
        p = Process(target=reader.find_text_async, args=(result, text, ))
        p.start()
        p.join(5)

        if p.is_alive():
            logging.WARNING("Manual terminating the process 'find_text_async'")
            p.terminate()

लेकिन अजवाइन मास्टर शाखा के साथ यह साईस:

फ़ाइल "/usr/lib/python3.5/multiprocessing/process.py", लाइन 103, शुरुआत में
'डेमोनिक प्रक्रियाओं को बच्चे पैदा करने की अनुमति नहीं है'
अभिकथन: डेमोनिक प्रक्रियाओं को बच्चे पैदा करने की अनुमति नहीं है

संपादित करें

मैंने बिलियर्ड के साथ मल्टीप्रोसेसिंग को बदल दिया और यह काम करता है!

from billiard import Process, Value