Hello community, here is the log from the commit of package python-billiard for openSUSE:Factory checked in at 2013-09-26 19:46:02 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-billiard (Old) and /work/SRC/openSUSE:Factory/.python-billiard.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-billiard" Changes: -------- --- /work/SRC/openSUSE:Factory/python-billiard/python-billiard.changes 2013-06-29 22:25:57.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.python-billiard.new/python-billiard.changes 2013-09-26 19:46:04.000000000 +0200 @@ -1,0 +2,19 @@ +Wed Sep 25 18:26:02 UTC 2013 - p.drou...@gmail.com + +- Update to version 2.7.3.32 + + Fixed compatibility with Python 3.3 + + Process boostrap: Now ignores errors while flushing stdout (Issue #16) +- Changes from version 2.7.3.31 + + Recent changes broke support for running without C extension (Issue #57) +- Changes from version 2.7.3.30 + + Fixed ImportError in billiard._ext +- Changes from version 2.7.3.29 + + Compilation: Fixed improper handling of HAVE_SEM_OPEN (Issue #55) + + Process now releases logging locks after fork. + + Pool.terminate_job now ignores No such process errors. + + billiard.Pool entrypoint did not support new arguments to billiard.pool.Pool + + Connection inbound buffer size increased from 1kb to 128kb. + + C extension cleaned up by properly adding a namespace to symbols. + +_exit_function now works even if thread wakes up after gc collect. + +------------------------------------------------------------------- Old: ---- billiard-2.7.3.28.tar.gz New: ---- billiard-2.7.3.32.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-billiard.spec ++++++ --- /var/tmp/diff_new_pack.9MaD4V/_old 2013-09-26 19:46:05.000000000 +0200 +++ /var/tmp/diff_new_pack.9MaD4V/_new 2013-09-26 19:46:05.000000000 +0200 @@ -17,7 +17,7 @@ Name: python-billiard -Version: 2.7.3.28 +Version: 2.7.3.32 Release: 0 Url: http://github.com/ask/billiard Summary: Python multiprocessing fork @@ -53,6 +53,9 @@ %install python setup.py install --prefix=%{_prefix} --root=%{buildroot} +# Remove hidden files from generated documentation directory +rm -r Doc/html/.doctrees +rm -r Doc/html/.buildinfo %check python setup.py test ++++++ billiard-2.7.3.28.tar.gz -> billiard-2.7.3.32.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/billiard-2.7.3.28/CHANGES.txt new/billiard-2.7.3.32/CHANGES.txt --- old/billiard-2.7.3.28/CHANGES.txt 2013-04-16 21:38:21.000000000 +0200 +++ new/billiard-2.7.3.32/CHANGES.txt 2013-08-16 16:16:48.000000000 +0200 @@ -1,3 +1,44 @@ +2.7.3.32 - 2012-08-16 +--------------------- + +- Fixed compatibility with Python 3.3 + +- Process boostrap: Now ignores errors while flushing stdout (Issue #16). + +2.7.3.31 - 2012-07-04 +--------------------- + +- Recent changes broke support for running without C extension (Issue #57). + +2.7.3.30 - 2012-06-28 +--------------------- + +- Fixed ImportError in billiard._ext + +2.7.3.29 - 2013-06-28 +--------------------- + +- Compilation: Fixed improper handling of HAVE_SEM_OPEN (Issue #55) + + Fix contributed by Krzysztof Jagiello. + +- Process now releases logging locks after fork. + + This previously happened in Pool, but it was done too late + as processes logs when they bootstrap. + +- Pool.terminate_job now ignores `No such process` errors. + +- billiard.Pool entrypoint did not support new arguments + to billiard.pool.Pool + +- Connection inbound buffer size increased from 1kb to 128kb. + +- C extension cleaned up by properly adding a namespace to symbols. + +- _exit_function now works even if thread wakes up after gc collect. + + 2.7.3.28 - 2013-04-16 --------------------- diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/billiard-2.7.3.28/Modules/_billiard/connection.h new/billiard-2.7.3.32/Modules/_billiard/connection.h --- old/billiard-2.7.3.28/Modules/_billiard/connection.h 2013-04-16 21:34:07.000000000 +0200 +++ new/billiard-2.7.3.32/Modules/_billiard/connection.h 2013-08-16 16:15:39.000000000 +0200 @@ -232,12 +232,12 @@ if (freeme == NULL) { result = PyInt_FromSsize_t(res); } else { - result = PyObject_CallFunction(BufferTooShort, + result = PyObject_CallFunction(Billiard_BufferTooShort, F_RBUFFER "#", freeme, res); PyMem_Free(freeme); if (result) { - PyErr_SetObject(BufferTooShort, result); + PyErr_SetObject(Billiard_BufferTooShort, result); Py_DECREF(result); } goto _error; @@ -295,12 +295,12 @@ if (freeme == NULL) { result = PyInt_FromSsize_t(res); } else { - result = PyObject_CallFunction(BufferTooShort, + result = PyObject_CallFunction(Billiard_BufferTooShort, F_RBUFFER "#", freeme, res); PyMem_Free(freeme); if (result) { - PyErr_SetObject(BufferTooShort, result); + PyErr_SetObject(Billiard_BufferTooShort, result); Py_DECREF(result); } goto _error; @@ -323,6 +323,28 @@ */ static PyObject * +Billiard_connection_send_offset(BilliardConnectionObject *self, PyObject *args) +{ + char *buf = NULL; + Py_ssize_t len = 0; + Py_ssize_t offset = 0; + ssize_t written = 0; + + if (!PyArg_ParseTuple(args, "s#n", &buf, &len, &offset)) + return NULL; + + CHECK_WRITABLE(self); + + written = _Billiard_conn_send_offset(self->handle, buf, (size_t)len, offset); + if (written < 0) { + Billiard_SetError(NULL, MP_SOCKET_ERROR); + return NULL; + } + + return PyInt_FromSsize_t((Py_ssize_t)written); +} + +static PyObject * Billiard_connection_send_obj(BilliardConnectionObject *self, PyObject *obj) { char *buffer; @@ -332,8 +354,9 @@ CHECK_WRITABLE(self); - pickled_string = PyObject_CallFunctionObjArgs(pickle_dumps, obj, - pickle_protocol, NULL); + pickled_string = PyObject_CallFunctionObjArgs( + Billiard_pickle_dumps, obj, Billiard_pickle_protocol, NULL + ); if (!pickled_string) goto failure; @@ -342,8 +365,8 @@ res = Billiard_conn_send_string(self, buffer, (int)length); - if (res < 0) { - Billiard_SetError(PyExc_IOError, res); + if (res != MP_SUCCESS) { + Billiard_SetError(NULL, res); goto failure; } @@ -356,6 +379,45 @@ } static PyObject * +Billiard_connection_recv_payload(BilliardConnectionObject *self) +{ + char *freeme = NULL; + Py_ssize_t res; + PyObject *view = NULL; + PyObject *result = NULL; + + CHECK_READABLE(self); + + res = Billiard_conn_recv_string(self, self->buffer, CONNECTION_BUFFER_SIZE, + &freeme, PY_SSIZE_T_MAX); + if (res < 0) { + if (res == MP_BAD_MESSAGE_LENGTH) { + if ((self->flags & WRITABLE) == 0) { + Py_BEGIN_ALLOW_THREADS; + CLOSE(self->handle); + Py_END_ALLOW_THREADS; + self->handle = INVALID_HANDLE_VALUE; + } else { + self->flags = WRITABLE; + } + } + Billiard_SetError(PyExc_IOError, res); + goto error; + } else { + if (freeme == NULL) { + view = PyBuffer_FromMemory(self->buffer, res); + } else { + view = PyString_FromStringAndSize(freeme, res); + PyMem_Free(freeme); + } + } + //Py_XDECREF(view); + return view; +error: + return NULL; +} + +static PyObject * Billiard_connection_recv_obj(BilliardConnectionObject *self) { char *freeme = NULL; @@ -389,7 +451,7 @@ } if (temp) - result = PyObject_CallFunctionObjArgs(pickle_loads, + result = PyObject_CallFunctionObjArgs(Billiard_pickle_loads, temp, NULL); Py_XDECREF(temp); return result; @@ -508,9 +570,12 @@ {"send", (PyCFunction)Billiard_connection_send_obj, METH_O, "send a (picklable) object"}, + {"send_offset", (PyCFunction)Billiard_connection_send_offset, METH_VARARGS, + "send string/buffer (non-blocking)"}, {"recv", (PyCFunction)Billiard_connection_recv_obj, METH_NOARGS, "receive a (picklable) object"}, - + {"recv_payload", (PyCFunction)Billiard_connection_recv_payload, METH_NOARGS, + "receive raw payload (not unpickled)"}, {"poll", (PyCFunction)Billiard_connection_poll, METH_VARARGS, "whether there is any input available to be read"}, {"fileno", (PyCFunction)Billiard_connection_fileno, METH_NOARGS, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/billiard-2.7.3.28/Modules/_billiard/multiprocessing.c new/billiard-2.7.3.32/Modules/_billiard/multiprocessing.c --- old/billiard-2.7.3.28/Modules/_billiard/multiprocessing.c 2013-04-16 21:34:07.000000000 +0200 +++ new/billiard-2.7.3.32/Modules/_billiard/multiprocessing.c 2013-05-24 12:10:10.000000000 +0200 @@ -17,8 +17,10 @@ PyObject *create_win32_namespace(void); -PyObject *pickle_dumps, *pickle_loads, *pickle_protocol; -PyObject *ProcessError, *BufferTooShort; +PyObject *Billiard_pickle_dumps; +PyObject *Billiard_pickle_loads; +PyObject *Billiard_pickle_protocol; +PyObject *Billiard_BufferTooShort; /* * Function which raises exceptions based on error codes @@ -28,6 +30,8 @@ Billiard_SetError(PyObject *Type, int num) { switch (num) { + case MP_SUCCESS: + break; #ifdef MS_WINDOWS case MP_STANDARD_ERROR: if (Type == NULL) @@ -233,16 +237,16 @@ temp = PyImport_ImportModule(PICKLE_MODULE); if (!temp) return; - pickle_dumps = PyObject_GetAttrString(temp, "dumps"); - pickle_loads = PyObject_GetAttrString(temp, "loads"); - pickle_protocol = PyObject_GetAttrString(temp, "HIGHEST_PROTOCOL"); + Billiard_pickle_dumps = PyObject_GetAttrString(temp, "dumps"); + Billiard_pickle_loads = PyObject_GetAttrString(temp, "loads"); + Billiard_pickle_protocol = PyObject_GetAttrString(temp, "HIGHEST_PROTOCOL"); Py_XDECREF(temp); /* Get copy of BufferTooShort */ temp = PyImport_ImportModule("billiard"); if (!temp) return; - BufferTooShort = PyObject_GetAttrString(temp, "BufferTooShort"); + Billiard_BufferTooShort = PyObject_GetAttrString(temp, "BufferTooShort"); Py_XDECREF(temp); /* Add connection type to module */ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/billiard-2.7.3.28/Modules/_billiard/multiprocessing.h new/billiard-2.7.3.32/Modules/_billiard/multiprocessing.h --- old/billiard-2.7.3.28/Modules/_billiard/multiprocessing.h 2013-04-16 21:34:07.000000000 +0200 +++ new/billiard-2.7.3.32/Modules/_billiard/multiprocessing.h 2013-05-24 12:10:10.000000000 +0200 @@ -130,10 +130,10 @@ * Externs - not all will really exist on all platforms */ -extern PyObject *pickle_dumps; -extern PyObject *pickle_loads; -extern PyObject *pickle_protocol; -extern PyObject *BufferTooShort; +extern PyObject *Billiard_pickle_dumps; +extern PyObject *Billiard_pickle_loads; +extern PyObject *Billiard_pickle_protocol; +extern PyObject *Billiard_BufferTooShort; extern PyTypeObject BilliardSemLockType; extern PyTypeObject BilliardConnectionType; extern PyTypeObject BilliardPipeConnectionType; @@ -165,7 +165,7 @@ * Connection definition */ -#define CONNECTION_BUFFER_SIZE 1024 +#define CONNECTION_BUFFER_SIZE 131072 typedef struct { PyObject_HEAD diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/billiard-2.7.3.28/Modules/_billiard/socket_connection.c new/billiard-2.7.3.32/Modules/_billiard/socket_connection.c --- old/billiard-2.7.3.28/Modules/_billiard/socket_connection.c 2013-04-16 21:34:07.000000000 +0200 +++ new/billiard-2.7.3.32/Modules/_billiard/socket_connection.c 2013-08-16 16:15:39.000000000 +0200 @@ -22,6 +22,32 @@ * Send string to file descriptor */ +void _Billiard_sockblock(int fd, int blocking) +{ +#ifdef MS_WINDOWS + unsigned long mode = blocking ? 0 : 1; + ioctlsocket(fd, FOINBIO, &mode); +#else + int flags = fcntl(fd, F_GETFL, 0); + if (flags > 0) { + flags = blocking ? (flags &~ O_NONBLOCK) : (flags | O_NONBLOCK); + fcntl(fd, F_SETFL, flags); + } +#endif +} + +static ssize_t +_Billiard_conn_send_offset(HANDLE fd, char *string, Py_ssize_t len, Py_ssize_t offset) { + char *p = string; + p += offset; + ssize_t res = 0; + + _Billiard_sockblock(fd, 0); + res = WRITE(fd, p, (size_t)len - offset); + _Billiard_sockblock(fd, 1); + return res; +} + static Py_ssize_t _Billiard_conn_sendall(HANDLE h, char *string, size_t length) { @@ -100,8 +126,9 @@ lenbuff = htonl((UINT32)length); Py_BEGIN_ALLOW_THREADS - res = _Billiard_conn_sendall(conn->handle, (char*)&lenbuff, 4) || - _Billiard_conn_sendall(conn->handle, string, length); + res = _Billiard_conn_sendall(conn->handle, (char*)&lenbuff, 4); + if (res == MP_SUCCESS) + res = _Billiard_conn_sendall(conn->handle, string, length); Py_END_ALLOW_THREADS } return res; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/billiard-2.7.3.28/PKG-INFO new/billiard-2.7.3.32/PKG-INFO --- old/billiard-2.7.3.28/PKG-INFO 2013-04-16 21:39:05.000000000 +0200 +++ new/billiard-2.7.3.32/PKG-INFO 2013-08-16 16:19:24.000000000 +0200 @@ -1,6 +1,6 @@ Metadata-Version: 1.1 Name: billiard -Version: 2.7.3.28 +Version: 2.7.3.32 Summary: Python multiprocessing fork with improvements and bugfixes Home-page: http://github.com/celery/billiard Author: Ask Solem', @@ -9,7 +9,7 @@ Description: ======== billiard ======== - :version: 2.7.3.28 + :version: 2.7.3.32 About ----- @@ -45,6 +45,47 @@ Changes =========== + 2.7.3.32 - 2012-08-16 + --------------------- + + - Fixed compatibility with Python 3.3 + + - Process boostrap: Now ignores errors while flushing stdout (Issue #16). + + 2.7.3.31 - 2012-07-04 + --------------------- + + - Recent changes broke support for running without C extension (Issue #57). + + 2.7.3.30 - 2012-06-28 + --------------------- + + - Fixed ImportError in billiard._ext + + 2.7.3.29 - 2013-06-28 + --------------------- + + - Compilation: Fixed improper handling of HAVE_SEM_OPEN (Issue #55) + + Fix contributed by Krzysztof Jagiello. + + - Process now releases logging locks after fork. + + This previously happened in Pool, but it was done too late + as processes logs when they bootstrap. + + - Pool.terminate_job now ignores `No such process` errors. + + - billiard.Pool entrypoint did not support new arguments + to billiard.pool.Pool + + - Connection inbound buffer size increased from 1kb to 128kb. + + - C extension cleaned up by properly adding a namespace to symbols. + + - _exit_function now works even if thread wakes up after gc collect. + + 2.7.3.28 - 2013-04-16 --------------------- diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/billiard-2.7.3.28/README.rst new/billiard-2.7.3.32/README.rst --- old/billiard-2.7.3.28/README.rst 2013-04-16 21:38:31.000000000 +0200 +++ new/billiard-2.7.3.32/README.rst 2013-08-16 16:17:01.000000000 +0200 @@ -1,7 +1,7 @@ ======== billiard ======== -:version: 2.7.3.28 +:version: 2.7.3.32 About ----- diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/billiard-2.7.3.28/billiard/__init__.py new/billiard-2.7.3.32/billiard/__init__.py --- old/billiard-2.7.3.28/billiard/__init__.py 2013-04-16 21:38:26.000000000 +0200 +++ new/billiard-2.7.3.32/billiard/__init__.py 2013-08-16 16:16:57.000000000 +0200 @@ -20,7 +20,7 @@ from __future__ import absolute_import from __future__ import with_statement -VERSION = (2, 7, 3, 28) +VERSION = (2, 7, 3, 32) __version__ = ".".join(map(str, VERSION[0:4])) + "".join(VERSION[4:]) __author__ = 'R Oudkerk / Python Software Foundation' __author_email__ = 'python-...@python.org' @@ -232,7 +232,11 @@ return JoinableQueue(maxsize) -def Pool(processes=None, initializer=None, initargs=(), maxtasksperchild=None): +def Pool(processes=None, initializer=None, initargs=(), maxtasksperchild=None, + timeout=None, soft_timeout=None, lost_worker_timeout=None, + max_restarts=None, max_restart_freq=1, on_process_up=None, + on_process_down=None, on_timeout_set=None, on_timeout_cancel=None, + threads=True, semaphore=None, putlocks=False, allow_restart=False): ''' Returns a process pool object ''' diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/billiard-2.7.3.28/billiard/_ext.py new/billiard-2.7.3.32/billiard/_ext.py --- old/billiard-2.7.3.28/billiard/_ext.py 2013-03-04 15:02:20.000000000 +0100 +++ new/billiard-2.7.3.32/billiard/_ext.py 2013-08-16 16:15:39.000000000 +0200 @@ -4,6 +4,11 @@ supports_exec = True +try: + import _winapi as win32 +except ImportError: # pragma: no cover + win32 = None + if sys.platform.startswith("java"): _billiard = None else: @@ -18,7 +23,8 @@ from multiprocessing.connection import Connection # noqa PipeConnection = getattr(_billiard, "PipeConnection", None) - win32 = getattr(_billiard, "win32", None) + if win32 is None: + win32 = getattr(_billiard, "win32", None) # noqa def ensure_multiprocessing(): diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/billiard-2.7.3.28/billiard/common.py new/billiard-2.7.3.32/billiard/common.py --- old/billiard-2.7.3.28/billiard/common.py 2013-04-16 18:21:07.000000000 +0200 +++ new/billiard-2.7.3.32/billiard/common.py 2013-08-15 14:45:27.000000000 +0200 @@ -1,12 +1,41 @@ +# -*- coding: utf-8 -*- +""" +This module contains utilities added by billiard, to keep +"non-core" functionality out of ``.util``.""" from __future__ import absolute_import import signal import sys from time import time +import pickle as pypickle +try: + import cPickle as cpickle +except ImportError: # pragma: no cover + cpickle = None # noqa from .exceptions import RestartFreqExceeded +if sys.version_info < (2, 6): # pragma: no cover + # cPickle does not use absolute_imports + pickle = pypickle + pickle_load = pypickle.load + pickle_loads = pypickle.loads +else: + pickle = cpickle or pypickle + pickle_load = pickle.load + pickle_loads = pickle.loads + +# cPickle.loads does not support buffer() objects, +# but we can just create a StringIO and use load. +if sys.version_info[0] == 3: + from io import BytesIO +else: + try: + from cStringIO import StringIO as BytesIO # noqa + except ImportError: + from StringIO import StringIO as BytesIO # noqa + TERMSIGS = ( 'SIGHUP', 'SIGQUIT', @@ -30,6 +59,11 @@ ) +def pickle_loads(s, load=pickle_load): + # used to support buffer objects + return load(BytesIO(s)) + + def _shutdown_cleanup(signum, frame): sys.exit(-(256 - signum)) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/billiard-2.7.3.28/billiard/pool.py new/billiard-2.7.3.32/billiard/pool.py --- old/billiard-2.7.3.28/billiard/pool.py 2013-04-16 21:34:07.000000000 +0200 +++ new/billiard-2.7.3.32/billiard/pool.py 2013-08-16 16:15:39.000000000 +0200 @@ -17,7 +17,6 @@ import collections import errno import itertools -import logging import os import platform import signal @@ -29,7 +28,7 @@ from . import Event, Process, cpu_count from . import util -from .common import reset_signals, restart_state +from .common import pickle_loads, reset_signals, restart_state from .compat import get_errno from .einfo import ExceptionInfo from .exceptions import ( @@ -163,15 +162,6 @@ if self._value < self._initial_value: self._value += 1 cond.notify_all() - if __debug__: - self._note( - "%s.release: success, value=%s", self, self._value, - ) - else: - if __debug__: - self._note( - "%s.release: success, value=%s (unchanged)" % ( - self, self._value)) def clear(self): while self._value < self._initial_value: @@ -184,14 +174,6 @@ if self._Semaphore__value < self._initial_value: self._Semaphore__value += 1 cond.notifyAll() - if __debug__: - self._note("%s.release: success, value=%s", - self, self._Semaphore__value) - else: - if __debug__: - self._note( - "%s.release: success, value=%s (unchanged)" % ( - self, self._Semaphore__value)) def clear(self): # noqa while self._Semaphore__value < self._initial_value: @@ -233,28 +215,26 @@ def worker(inqueue, outqueue, initializer=None, initargs=(), maxtasks=None, sentinel=None): - # Re-init logging system. - # Workaround for http://bugs.python.org/issue6721#msg140215 - # Python logging module uses RLock() objects which are broken after - # fork. This can result in a deadlock (Issue #496). - logger_names = logging.Logger.manager.loggerDict.keys() - logger_names.append(None) # for root logger - for name in logger_names: - for handler in logging.getLogger(name).handlers: - handler.createLock() - logging._lock = threading.RLock() - pid = os.getpid() assert maxtasks is None or (type(maxtasks) == int and maxtasks > 0) put = outqueue.put get = inqueue.get + loads = pickle_loads if hasattr(inqueue, '_reader'): - def poll(timeout): - if inqueue._reader.poll(timeout): - return True, get() - return False, None + if hasattr(inqueue, 'get_payload') and inqueue.get_payload: + get_payload = inqueue.get_payload + + def poll(timeout): + if inqueue._reader.poll(timeout): + return True, loads(get_payload()) + return False, None + else: + def poll(timeout): + if inqueue._reader.poll(timeout): + return True, get() + return False, None else: def poll(timeout): # noqa @@ -1236,8 +1216,13 @@ return result def terminate_job(self, pid, sig=None): - self.signalled.add(pid) - _kill(pid, sig or signal.SIGTERM) + try: + _kill(pid, sig or signal.SIGTERM) + except OSError, exc: + if get_errno(exc) != errno.ESRCH: + raise + else: + self.signalled.add(pid) def map_async(self, func, iterable, chunksize=None, callback=None, error_callback=None): diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/billiard-2.7.3.28/billiard/process.py new/billiard-2.7.3.32/billiard/process.py --- old/billiard-2.7.3.28/billiard/process.py 2013-04-16 13:25:17.000000000 +0200 +++ new/billiard-2.7.3.32/billiard/process.py 2013-08-16 16:15:39.000000000 +0200 @@ -19,6 +19,8 @@ import signal import itertools import binascii +import logging +import threading from .compat import bytes try: @@ -45,9 +47,17 @@ def _cleanup(): # check for processes which have finished - for p in list(_current_process._children): - if p._popen.poll() is not None: - _current_process._children.discard(p) + if _current_process is not None: + for p in list(_current_process._children): + if p._popen.poll() is not None: + _current_process._children.discard(p) + + +def _maybe_flush(f): + try: + f.flush() + except (AttributeError, EnvironmentError, NotImplementedError): + pass def active_children(_cleanup=_cleanup): @@ -59,7 +69,9 @@ except TypeError: # called after gc collect so _cleanup does not exist anymore return [] - return list(_current_process._children) + if _current_process is not None: + return list(_current_process._children) + return [] class Process(object): @@ -242,6 +254,18 @@ pass old_process = _current_process _current_process = self + + # Re-init logging system. + # Workaround for http://bugs.python.org/issue6721#msg140215 + # Python logging module uses RLock() objects which are broken after + # fork. This can result in a deadlock (Celery Issue #496). + logger_names = logging.Logger.manager.loggerDict.keys() + logger_names.append(None) # for root logger + for name in logger_names: + for handler in logging.getLogger(name).handlers: + handler.createLock() + logging._lock = threading.RLock() + try: util._finalizer_registry.clear() util._run_after_forkers() @@ -262,7 +286,7 @@ exitcode = e.args[0] else: sys.stderr.write(str(e.args[0]) + '\n') - sys.stderr.flush() + _maybe_flush(sys.stderr) exitcode = 0 if isinstance(e.args[0], str) else 1 except: exitcode = 1 @@ -273,8 +297,8 @@ finally: util.info('process %s exiting with exitcode %d', self.pid, exitcode) - sys.stdout.flush() - sys.stderr.flush() + _maybe_flush(sys.stdout) + _maybe_flush(sys.stderr) return exitcode # diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/billiard-2.7.3.28/billiard/queues.py new/billiard-2.7.3.32/billiard/queues.py --- old/billiard-2.7.3.28/billiard/queues.py 2013-04-15 16:52:46.000000000 +0200 +++ new/billiard-2.7.3.32/billiard/queues.py 2013-08-16 16:15:39.000000000 +0200 @@ -334,6 +334,10 @@ def _make_methods(self): recv = self._reader.recv + try: + recv_payload = self._reader.recv_payload + except AttributeError: + recv_payload = None # C extension not installed rlock = self._rlock def get(): @@ -341,6 +345,12 @@ return recv() self.get = get + if recv_payload is not None: + def get_payload(): + with rlock: + return recv_payload() + self.get_payload = get_payload + if self._wlock is None: # writes to a message oriented win32 pipe are atomic self.put = self._writer.send diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/billiard-2.7.3.28/billiard/util.py new/billiard-2.7.3.32/billiard/util.py --- old/billiard-2.7.3.28/billiard/util.py 2013-04-15 16:52:46.000000000 +0200 +++ new/billiard-2.7.3.32/billiard/util.py 2013-08-16 16:15:39.000000000 +0200 @@ -244,7 +244,9 @@ return x + '>' -def _run_finalizers(minpriority=None): +def _run_finalizers(minpriority=None, + _finalizer_registry=_finalizer_registry, + sub_debug=sub_debug, error=error): ''' Run all finalizers whose exit priority is not None and at least minpriority @@ -280,7 +282,9 @@ return _exiting or _exiting is None -def _exit_function(): +def _exit_function(info=info, debug=debug, + active_children=active_children, + _run_finalizers=_run_finalizers): ''' Clean up on exit ''' diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/billiard-2.7.3.28/billiard.egg-info/PKG-INFO new/billiard-2.7.3.32/billiard.egg-info/PKG-INFO --- old/billiard-2.7.3.28/billiard.egg-info/PKG-INFO 2013-04-16 21:38:57.000000000 +0200 +++ new/billiard-2.7.3.32/billiard.egg-info/PKG-INFO 2013-08-16 16:19:18.000000000 +0200 @@ -1,6 +1,6 @@ Metadata-Version: 1.1 Name: billiard -Version: 2.7.3.28 +Version: 2.7.3.32 Summary: Python multiprocessing fork with improvements and bugfixes Home-page: http://github.com/celery/billiard Author: Ask Solem', @@ -9,7 +9,7 @@ Description: ======== billiard ======== - :version: 2.7.3.28 + :version: 2.7.3.32 About ----- @@ -45,6 +45,47 @@ Changes =========== + 2.7.3.32 - 2012-08-16 + --------------------- + + - Fixed compatibility with Python 3.3 + + - Process boostrap: Now ignores errors while flushing stdout (Issue #16). + + 2.7.3.31 - 2012-07-04 + --------------------- + + - Recent changes broke support for running without C extension (Issue #57). + + 2.7.3.30 - 2012-06-28 + --------------------- + + - Fixed ImportError in billiard._ext + + 2.7.3.29 - 2013-06-28 + --------------------- + + - Compilation: Fixed improper handling of HAVE_SEM_OPEN (Issue #55) + + Fix contributed by Krzysztof Jagiello. + + - Process now releases logging locks after fork. + + This previously happened in Pool, but it was done too late + as processes logs when they bootstrap. + + - Pool.terminate_job now ignores `No such process` errors. + + - billiard.Pool entrypoint did not support new arguments + to billiard.pool.Pool + + - Connection inbound buffer size increased from 1kb to 128kb. + + - C extension cleaned up by properly adding a namespace to symbols. + + - _exit_function now works even if thread wakes up after gc collect. + + 2.7.3.28 - 2013-04-16 --------------------- diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/billiard-2.7.3.28/setup.py new/billiard-2.7.3.32/setup.py --- old/billiard-2.7.3.28/setup.py 2013-04-15 18:56:53.000000000 +0200 +++ new/billiard-2.7.3.32/setup.py 2013-08-16 16:15:39.000000000 +0200 @@ -120,7 +120,7 @@ libraries = [] elif sys.platform in ('freebsd7', 'freebsd8', 'freebsd9', 'freebsd10'): macros = dict( # FreeBSD 7+ - HAVE_SEM_OPEN=int(sysconfig.get_config_var('HAVE_SEM_OPEN') and not bool(sysconfig.get_config_var('POSIX_SEMAPHORES_NOT_ENABLED'))), + HAVE_SEM_OPEN=bool(sysconfig.get_config_var('HAVE_SEM_OPEN') and not bool(sysconfig.get_config_var('POSIX_SEMAPHORES_NOT_ENABLED'))), HAVE_SEM_TIMEDWAIT=1, HAVE_FD_TRANSFER=1, ) -- To unsubscribe, e-mail: opensuse-commit+unsubscr...@opensuse.org For additional commands, e-mail: opensuse-commit+h...@opensuse.org
