swift 2.32.1__py2.py3-none-any.whl → 2.33.1__py2.py3-none-any.whl

swift/container/sharder.py

@@ -50,6 +50,8 @@ CLEAVE_SUCCESS = 0
 CLEAVE_FAILED = 1
 CLEAVE_EMPTY = 2
 
+DEFAULT_PERIODIC_WARNINGS_INTERVAL = 24 * 3600
+
 
 def sharding_enabled(broker):
     # NB all shards will by default have been created with
@@ -852,18 +854,7 @@ class ContainerSharder(ContainerSharderConf, ContainerReplicator):
         ContainerReplicator.__init__(self, conf, logger=logger)
         ContainerSharderConf.__init__(self, conf)
         ContainerSharderConf.validate_conf(self)
-        if conf.get('auto_create_account_prefix'):
-            self.logger.warning('Option auto_create_account_prefix is '
-                                'deprecated. Configure '
-                                'auto_create_account_prefix under the '
-                                'swift-constraints section of '
-                                'swift.conf. This option will '
-                                'be ignored in a future release.')
-            auto_create_account_prefix = \
-                self.conf['auto_create_account_prefix']
-        else:
-            auto_create_account_prefix = AUTO_CREATE_ACCOUNT_PREFIX
-        self.shards_account_prefix = (auto_create_account_prefix + 'shards_')
+        self.shards_account_prefix = (AUTO_CREATE_ACCOUNT_PREFIX + 'shards_')
         self.sharding_candidates = []
         self.shrinking_candidates = []
         replica_count = self.ring.replica_count
@@ -908,9 +899,13 @@ class ContainerSharder(ContainerSharderConf, ContainerReplicator):
                 (internal_client_conf_path, err))
         self.stats_interval = float(conf.get('stats_interval', '3600'))
         self.reported = 0
+        self.periodic_warnings_interval = float(
+            conf.get('periodic_warnings_interval',
+                     DEFAULT_PERIODIC_WARNINGS_INTERVAL))
+        self.periodic_warnings_start = time.time()
+        self.periodic_warnings = set()
 
-    def _format_log_msg(self, broker, msg, *args):
-        # make best effort to include broker properties...
+    def _get_broker_details(self, broker):
         try:
             db_file = broker.db_file
         except Exception:  # noqa
@@ -919,7 +914,11 @@ class ContainerSharder(ContainerSharderConf, ContainerReplicator):
             path = broker.path
         except Exception:  # noqa
             path = ''
+        return db_file, path
 
+    def _format_log_msg(self, broker, msg, *args):
+        # make best effort to include broker properties...
+        db_file, path = self._get_broker_details(broker)
         if args:
             msg = msg % args
         return '%s, path: %s, db: %s' % (msg, quote(path), db_file)
@@ -939,6 +938,19 @@ class ContainerSharder(ContainerSharderConf, ContainerReplicator):
     def warning(self, broker, msg, *args, **kwargs):
         self._log(logging.WARNING, broker, msg, *args, **kwargs)
 
+    def periodic_warning(self, broker, msg, *args, **kwargs):
+        now = time.time()
+        if now - self.periodic_warnings_start >= \
+                self.periodic_warnings_interval:
+            self.periodic_warnings.clear()
+            self.periodic_warnings_start = now
+
+        db_file, path = self._get_broker_details(broker)
+        key = (db_file, msg)
+        if key not in self.periodic_warnings:
+            self.periodic_warnings.add(key)
+            self._log(logging.WARNING, broker, msg, *args, **kwargs)
+
     def error(self, broker, msg, *args, **kwargs):
         self._log(logging.ERROR, broker, msg, *args, **kwargs)
 
@@ -1156,6 +1168,7 @@ class ContainerSharder(ContainerSharderConf, ContainerReplicator):
         params = params or {}
         params.setdefault('format', 'json')
         headers = {'X-Backend-Record-Type': 'shard',
+                   'X-Backend-Record-Shard-Format': 'full',
                    'X-Backend-Override-Deleted': 'true',
                    'X-Backend-Include-Deleted': str(include_deleted)}
         if newest:
@@ -1296,7 +1309,7 @@ class ContainerSharder(ContainerSharderConf, ContainerReplicator):
                 # Shrinking is how we resolve overlaps; we've got to
                 # allow multiple shards in that state
                 continue
-            shard_ranges = broker.get_shard_ranges(states=state)
+            shard_ranges = broker.get_shard_ranges(states=[state])
             # Transient overlaps can occur during the period immediately after
             # sharding if a root learns about new child shards before it learns
             # that the parent has sharded. These overlaps are normally
@@ -1549,8 +1562,8 @@ class ContainerSharder(ContainerSharderConf, ContainerReplicator):
         if broker.is_deleted():
             if broker.is_old_enough_to_reclaim(time.time(), self.reclaim_age) \
                     and not broker.is_empty_enough_to_reclaim():
-                self.warning(broker,
-                             'Reclaimable db stuck waiting for shrinking')
+                self.periodic_warning(
+                    broker, 'Reclaimable db stuck waiting for shrinking')
             # if the container has been marked as deleted, all metadata will
             # have been erased so no point auditing. But we want it to pass, in
             # case any objects exist inside it.
@@ -1678,11 +1691,15 @@ class ContainerSharder(ContainerSharderConf, ContainerReplicator):
                               dest_broker, node_id, info):
         success, responses = self._replicate_object(
             part, dest_broker.db_file, node_id)
+        replication_successes = responses.count(True)
         quorum = quorum_size(self.ring.replica_count)
-        if not success and responses.count(True) < quorum:
-            self.warning(broker, 'Failed to sufficiently replicate misplaced '
-                                 'objects to %s (not removing)',
-                         dest_shard_range)
+        if not success and replication_successes < quorum:
+            self.warning(
+                broker, 'Failed to sufficiently replicate misplaced objects '
+                        'shard %s in state %s: %s successes, %s required '
+                        '(not removing objects), shard db: %s',
+                dest_shard_range.name, dest_shard_range.state_text,
+                replication_successes, quorum, dest_broker.db_file)
             return False
 
         if broker.get_info()['id'] != info['id']:
@@ -1700,9 +1717,9 @@ class ContainerSharder(ContainerSharderConf, ContainerReplicator):
             success = True
 
         if not success:
-            self.warning(broker,
-                         'Refused to remove misplaced objects for dest %s',
-                         dest_shard_range)
+            self.warning(broker, 'Refused to remove misplaced objects for '
+                                 'dest %s in state %s',
+                         dest_shard_range.name, dest_shard_range.state_text)
         return success
 
     def _move_objects(self, src_broker, src_shard_range, policy_index,
@@ -1919,7 +1936,7 @@ class ContainerSharder(ContainerSharderConf, ContainerReplicator):
         # Create shard containers that are ready to receive redirected object
         # updates. Do this now, so that redirection can begin immediately
         # without waiting for cleaving to complete.
-        found_ranges = broker.get_shard_ranges(states=ShardRange.FOUND)
+        found_ranges = broker.get_shard_ranges(states=[ShardRange.FOUND])
         created_ranges = []
         for shard_range in found_ranges:
             self._increment_stat('created', 'attempted')
@@ -2059,10 +2076,13 @@ class ContainerSharder(ContainerSharderConf, ContainerReplicator):
                 # insufficient replication or replication not even attempted;
                 # break because we don't want to progress the cleave cursor
                 # until each shard range has been successfully cleaved
-                self.warning(broker,
-                             'Failed to sufficiently replicate cleaved shard '
-                             '%s: %s successes, %s required', shard_range,
-                             replication_successes, replication_quorum)
+                self.warning(
+                    broker, 'Failed to sufficiently replicate cleaved shard '
+                            '%s in state %s: %s successes, %s required, '
+                            'shard db: %s',
+                    shard_broker.path, shard_range.state_text,
+                    replication_successes, replication_quorum,
+                    shard_broker.db_file)
                 self._increment_stat('cleaved', 'failure', statsd=True)
                 result = CLEAVE_FAILED
             else:
@@ -2214,7 +2234,7 @@ class ContainerSharder(ContainerSharderConf, ContainerReplicator):
             else:
                 own_shard_range.update_state(ShardRange.SHARDED)
                 modified_shard_ranges = broker.get_shard_ranges(
-                    states=ShardRange.CLEAVED)
+                    states=[ShardRange.CLEAVED])
                 for sr in modified_shard_ranges:
                     sr.update_state(ShardRange.ACTIVE)
             if (not broker.is_root_container() and not

swift/container/updater.py

@@ -158,6 +158,7 @@ class ContainerUpdater(Daemon):
                     pid2filename[pid] = tmpfilename
                 else:
                     signal.signal(signal.SIGTERM, signal.SIG_DFL)
+                    os.environ.pop('NOTIFY_SOCKET', None)
                     eventlet_monkey_patch()
                     self.no_changes = 0
                     self.successes = 0

swift/obj/auditor.py

@@ -24,7 +24,7 @@ from contextlib import closing
 from eventlet import Timeout
 
 from swift.obj import diskfile, replicator
-from swift.common.exceptions import DiskFileQuarantined, DiskFileNotExist,\
+from swift.common.exceptions import DiskFileQuarantined, DiskFileNotExist, \
     DiskFileDeleted, DiskFileExpired, QuarantineRequest
 from swift.common.daemon import Daemon
 from swift.common.storage_policy import POLICIES
@@ -368,6 +368,7 @@ class ObjectAuditor(Daemon):
             return pid
         else:
             signal.signal(signal.SIGTERM, signal.SIG_DFL)
+            os.environ.pop('NOTIFY_SOCKET', None)
             if zero_byte_fps:
                 kwargs['zero_byte_fps'] = self.conf_zero_byte_fps
                 if sleep_between_zbf_scanner:

swift/obj/diskfile.py

@@ -65,7 +65,8 @@ from swift.common.utils import mkdirs, Timestamp, \
     get_md5_socket, F_SETPIPE_SZ, decode_timestamps, encode_timestamps, \
     MD5_OF_EMPTY_STRING, link_fd_to_path, \
     O_TMPFILE, makedirs_count, replace_partition_in_path, remove_directory, \
-    md5, is_file_older, non_negative_float
+    md5, is_file_older, non_negative_float, config_fallocate_value, \
+    fs_has_free_space, CooperativeIterator
 from swift.common.splice import splice, tee
 from swift.common.exceptions import DiskFileQuarantined, DiskFileNotExist, \
     DiskFileCollision, DiskFileNoSpace, DiskFileDeviceUnavailable, \
@@ -428,19 +429,23 @@ def consolidate_hashes(partition_dir):
     with lock_path(partition_dir):
         hashes = read_hashes(partition_dir)
 
-        found_invalidation_entry = False
+        found_invalidation_entry = hashes_updated = False
         try:
             with open(invalidations_file, 'r') as inv_fh:
                 for line in inv_fh:
                     found_invalidation_entry = True
                     suffix = line.strip()
+                    if not valid_suffix(suffix):
+                        continue
+                    hashes_updated = True
                     hashes[suffix] = None
         except (IOError, OSError) as e:
             if e.errno != errno.ENOENT:
                 raise
 
-        if found_invalidation_entry:
+        if hashes_updated:
             write_hashes(partition_dir, hashes)
+        if found_invalidation_entry:
             # Now that all the invalidations are reflected in hashes.pkl, it's
             # safe to clear out the invalidations file.
             with open(invalidations_file, 'wb') as inv_fh:
@@ -751,6 +756,8 @@ class BaseDiskFileManager(object):
                 replication_concurrency_per_device)
         self.replication_lock_timeout = int(conf.get(
             'replication_lock_timeout', 15))
+        self.fallocate_reserve, self.fallocate_is_percent = \
+            config_fallocate_value(conf.get('fallocate_reserve', '1%'))
 
         self.use_splice = False
         self.pipe_size = None
@@ -1793,10 +1800,12 @@ class BaseDiskFileWriter(object):
     :param bytes_per_sync: number bytes written between sync calls
     :param diskfile: the diskfile creating this DiskFileWriter instance
     :param next_part_power: the next partition power to be used
+    :param extension: the file extension to be used; may be used internally
+                      to distinguish between PUT/POST/DELETE operations
     """
 
     def __init__(self, name, datadir, size, bytes_per_sync, diskfile,
-                 next_part_power):
+                 next_part_power, extension='.data'):
         # Parameter tracking
         self._name = name
         self._datadir = datadir
@@ -1807,11 +1816,11 @@ class BaseDiskFileWriter(object):
         self._bytes_per_sync = bytes_per_sync
         self._diskfile = diskfile
         self.next_part_power = next_part_power
+        self._extension = extension
 
         # Internal attributes
         self._upload_size = 0
         self._last_sync = 0
-        self._extension = '.data'
         self._put_succeeded = False
 
     @property
@@ -1856,13 +1865,26 @@ class BaseDiskFileWriter(object):
                 # No more inodes in filesystem
                 raise DiskFileNoSpace()
             raise
-        if self._size is not None and self._size > 0:
+        if self._extension == '.ts':
+            # DELETEs always bypass any free-space reserve checks
+            pass
+        elif self._size:
             try:
                 fallocate(self._fd, self._size)
             except OSError as err:
                 if err.errno in (errno.ENOSPC, errno.EDQUOT):
                     raise DiskFileNoSpace()
                 raise
+        else:
+            # If we don't know the size (i.e. self._size is None) or the size
+            # is known to be zero, we still want to block writes once we're
+            # past the reserve threshold.
+            if not fs_has_free_space(
+                    self._fd,
+                    self.manager.fallocate_reserve,
+                    self.manager.fallocate_is_percent
+            ):
+                raise DiskFileNoSpace()
         return self
 
     def close(self):
@@ -2088,11 +2110,13 @@ class BaseDiskFileReader(object):
     :param pipe_size: size of pipe buffer used in zero-copy operations
     :param diskfile: the diskfile creating this DiskFileReader instance
     :param keep_cache: should resulting reads be kept in the buffer cache
+    :param cooperative_period: the period parameter when does cooperative
+                               yielding during file read
     """
     def __init__(self, fp, data_file, obj_size, etag,
                  disk_chunk_size, keep_cache_size, device_path, logger,
                  quarantine_hook, use_splice, pipe_size, diskfile,
-                 keep_cache=False):
+                 keep_cache=False, cooperative_period=0):
         # Parameter tracking
         self._fp = fp
         self._data_file = data_file
@@ -2111,6 +2135,7 @@ class BaseDiskFileReader(object):
             self._keep_cache = obj_size < keep_cache_size
         else:
             self._keep_cache = False
+        self._cooperative_period = cooperative_period
 
         # Internal Attributes
         self._iter_etag = None
@@ -2135,6 +2160,10 @@ class BaseDiskFileReader(object):
             self._iter_etag.update(chunk)
 
     def __iter__(self):
+        return CooperativeIterator(
+            self._inner_iter(), period=self._cooperative_period)
+
+    def _inner_iter(self):
         """Returns an iterator over the data file."""
         try:
             dropped_cache = 0
@@ -2953,7 +2982,7 @@ class BaseDiskFile(object):
         with self.open(current_time=current_time):
             return self.get_metadata()
 
-    def reader(self, keep_cache=False,
+    def reader(self, keep_cache=False, cooperative_period=0,
                _quarantine_hook=lambda m: None):
         """
         Return a :class:`swift.common.swob.Response` class compatible
@@ -2965,6 +2994,8 @@ class BaseDiskFile(object):
 
         :param keep_cache: caller's preference for keeping data read in the
                            OS buffer cache
+        :param cooperative_period: the period parameter for cooperative
+                                   yielding during file read
         :param _quarantine_hook: 1-arg callable called when obj quarantined;
                                  the arg is the reason for quarantine.
                                  Default is to ignore it.
@@ -2976,19 +3007,23 @@ class BaseDiskFile(object):
             self._metadata['ETag'], self._disk_chunk_size,
             self._manager.keep_cache_size, self._device_path, self._logger,
             use_splice=self._use_splice, quarantine_hook=_quarantine_hook,
-            pipe_size=self._pipe_size, diskfile=self, keep_cache=keep_cache)
+            pipe_size=self._pipe_size, diskfile=self, keep_cache=keep_cache,
+            cooperative_period=cooperative_period)
         # At this point the reader object is now responsible for closing
         # the file pointer.
         self._fp = None
         return dr
 
-    def writer(self, size=None):
+    def _writer(self, size, extension):
         return self.writer_cls(self._name, self._datadir, size,
                                self._bytes_per_sync, self,
-                               self.next_part_power)
+                               self.next_part_power, extension=extension)
+
+    def writer(self, size=None):
+        return self._writer(size, '.data')
 
     @contextmanager
-    def create(self, size=None):
+    def create(self, size=None, extension='.data'):
         """
         Context manager to create a file. We create a temporary file first, and
         then return a DiskFileWriter object to encapsulate the state.
@@ -3001,9 +3036,11 @@ class BaseDiskFile(object):
 
         :param size: optional initial size of file to explicitly allocate on
                      disk
+        :param extension: file extension to use for the newly-created file;
+                          defaults to ``.data`` for the sake of tests
         :raises DiskFileNoSpace: if a size is specified and allocation fails
         """
-        dfw = self.writer(size)
+        dfw = self._writer(size, extension)
         try:
             yield dfw.open()
         finally:
@@ -3019,8 +3056,7 @@ class BaseDiskFile(object):
         :raises DiskFileError: this implementation will raise the same
                             errors as the `create()` method.
         """
-        with self.create() as writer:
-            writer._extension = '.meta'
+        with self.create(extension='.meta') as writer:
             writer.put(metadata)
 
     def delete(self, timestamp):
@@ -3042,8 +3078,7 @@ class BaseDiskFile(object):
         """
         # this is dumb, only tests send in strings
         timestamp = Timestamp(timestamp)
-        with self.create() as deleter:
-            deleter._extension = '.ts'
+        with self.create(extension='.ts') as deleter:
             deleter.put({'X-Timestamp': timestamp.internal})
 
 
@@ -3136,11 +3171,12 @@ class ECDiskFileReader(BaseDiskFileReader):
     def __init__(self, fp, data_file, obj_size, etag,
                  disk_chunk_size, keep_cache_size, device_path, logger,
                  quarantine_hook, use_splice, pipe_size, diskfile,
-                 keep_cache=False):
+                 keep_cache=False, cooperative_period=0):
         super(ECDiskFileReader, self).__init__(
             fp, data_file, obj_size, etag,
             disk_chunk_size, keep_cache_size, device_path, logger,
-            quarantine_hook, use_splice, pipe_size, diskfile, keep_cache)
+            quarantine_hook, use_splice, pipe_size, diskfile, keep_cache,
+            cooperative_period)
         self.frag_buf = None
         self.frag_offset = 0
         self.frag_size = self._diskfile.policy.fragment_size

swift/obj/expirer.py

@@ -114,19 +114,7 @@ class ObjectExpirer(Daemon):
         self.reclaim_age = int(conf.get('reclaim_age', 604800))
 
     def read_conf_for_queue_access(self, swift):
-        if self.conf.get('auto_create_account_prefix'):
-            self.logger.warning('Option auto_create_account_prefix is '
-                                'deprecated. Configure '
-                                'auto_create_account_prefix under the '
-                                'swift-constraints section of '
-                                'swift.conf. This option will '
-                                'be ignored in a future release.')
-            auto_create_account_prefix = \
-                self.conf['auto_create_account_prefix']
-        else:
-            auto_create_account_prefix = AUTO_CREATE_ACCOUNT_PREFIX
-
-        self.expiring_objects_account = auto_create_account_prefix + \
+        self.expiring_objects_account = AUTO_CREATE_ACCOUNT_PREFIX + \
             (self.conf.get('expiring_objects_account_name') or
              'expiring_objects')
 

swift/obj/mem_diskfile.py

@@ -426,13 +426,14 @@ class DiskFile(object):
         with self.open(current_time=current_time):
             return self.get_metadata()
 
-    def reader(self, keep_cache=False):
+    def reader(self, keep_cache=False, cooperative_period=0):
         """
         Return a swift.common.swob.Response class compatible "app_iter"
         object. The responsibility of closing the open file is passed to the
         DiskFileReader object.
 
         :param keep_cache:
+        :param cooperative_period:
         """
         dr = DiskFileReader(self._name, self._fp,
                             int(self._metadata['Content-Length']),

swift/obj/mem_server.py

@@ -32,6 +32,7 @@ class ObjectController(server.ObjectController):
         :param conf: WSGI configuration parameter
         """
         self._filesystem = InMemoryFileSystem()
+        self.fallocate_reserve = 0
 
     def get_diskfile(self, device, partition, account, container, obj,
                      **kwargs):

swift/obj/replicator.py

@@ -493,7 +493,7 @@ class ObjectReplicator(Daemon):
                 return False
         return True
 
-    def update_deleted(self, job):
+    def revert(self, job):
         """
         High-level method that replicates a single partition that doesn't
         belong on this node.
@@ -993,7 +993,7 @@ class ObjectReplicator(Daemon):
                 except OSError:
                     continue
                 if job['delete']:
-                    self.run_pool.spawn(self.update_deleted, job)
+                    self.run_pool.spawn(self.revert, job)
                 else:
                     self.run_pool.spawn(self.update, job)
             current_nodes = None

swift/obj/server.py

@@ -42,7 +42,7 @@ from swift.common.exceptions import ConnectionTimeout, DiskFileQuarantined, \
     DiskFileNotExist, DiskFileCollision, DiskFileNoSpace, DiskFileDeleted, \
     DiskFileDeviceUnavailable, DiskFileExpired, ChunkReadTimeout, \
     ChunkReadError, DiskFileXattrNotSupported
-from swift.common.request_helpers import \
+from swift.common.request_helpers import resolve_ignore_range_header, \
     OBJECT_SYSMETA_CONTAINER_UPDATE_OVERRIDE_PREFIX
 from swift.obj import ssync_receiver
 from swift.common.http import is_success, HTTP_MOVED_PERMANENTLY
@@ -152,6 +152,7 @@ class ObjectController(BaseStorageServer):
             config_true_value(conf.get('keep_cache_private', 'false'))
         self.keep_cache_slo_manifest = \
             config_true_value(conf.get('keep_cache_slo_manifest', 'false'))
+        self.cooperative_period = int(conf.get("cooperative_period", 0))
 
         default_allowed_headers = '''
             content-disposition,
@@ -173,18 +174,8 @@ class ObjectController(BaseStorageServer):
         for header in extra_allowed_headers:
             if header not in RESERVED_DATAFILE_META:
                 self.allowed_headers.add(header)
-        if conf.get('auto_create_account_prefix'):
-            self.logger.warning('Option auto_create_account_prefix is '
-                                'deprecated. Configure '
-                                'auto_create_account_prefix under the '
-                                'swift-constraints section of '
-                                'swift.conf. This option will '
-                                'be ignored in a future release.')
-            self.auto_create_account_prefix = \
-                conf['auto_create_account_prefix']
-        else:
-            self.auto_create_account_prefix = AUTO_CREATE_ACCOUNT_PREFIX
 
+        self.auto_create_account_prefix = AUTO_CREATE_ACCOUNT_PREFIX
         self.expiring_objects_account = self.auto_create_account_prefix + \
             (conf.get('expiring_objects_account_name') or 'expiring_objects')
         self.expiring_objects_container_divisor = \
@@ -1090,14 +1081,7 @@ class ObjectController(BaseStorageServer):
         try:
             with disk_file.open(current_time=req_timestamp):
                 metadata = disk_file.get_metadata()
-                ignore_range_headers = set(
-                    h.strip().lower()
-                    for h in request.headers.get(
-                        'X-Backend-Ignore-Range-If-Metadata-Present',
-                        '').split(','))
-                if ignore_range_headers.intersection(
-                        h.lower() for h in metadata):
-                    request.headers.pop('Range', None)
+                resolve_ignore_range_header(request, metadata)
                 obj_size = int(metadata['Content-Length'])
                 file_x_ts = Timestamp(metadata['X-Timestamp'])
                 keep_cache = (
@@ -1114,10 +1098,15 @@ class ObjectController(BaseStorageServer):
                     )
                 )
                 conditional_etag = resolve_etag_is_at_header(request, metadata)
+                app_iter = disk_file.reader(
+                    keep_cache=keep_cache,
+                    cooperative_period=self.cooperative_period,
+                )
                 response = Response(
-                    app_iter=disk_file.reader(keep_cache=keep_cache),
-                    request=request, conditional_response=True,
-                    conditional_etag=conditional_etag)
+                    app_iter=app_iter, request=request,
+                    conditional_response=True,
+                    conditional_etag=conditional_etag,
+                )
                 response.headers['Content-Type'] = metadata.get(
                     'Content-Type', 'application/octet-stream')
                 for key, value in metadata.items():

swift/obj/updater.py

@@ -381,6 +381,7 @@ class ObjectUpdater(Daemon):
                     pids.append(pid)
                 else:
                     signal.signal(signal.SIGTERM, signal.SIG_DFL)
+                    os.environ.pop('NOTIFY_SOCKET', None)
                     eventlet_monkey_patch()
                     self.stats.reset()
                     forkbegin = time.time()