swift 2.23.3__py3-none-any.whl → 2.35.0__py3-none-any.whl

swift/obj/expirer.py

@@ -13,41 +13,156 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import six
+import urllib
 
 from random import random
 from time import time
+from optparse import OptionParser
 from os.path import join
-from swift import gettext_ as _
 from collections import defaultdict, deque
-import hashlib
 
 from eventlet import sleep, Timeout
 from eventlet.greenpool import GreenPool
 
-from swift.common.daemon import Daemon
+from swift.common.constraints import AUTO_CREATE_ACCOUNT_PREFIX
+from swift.common.daemon import Daemon, run_daemon
 from swift.common.internal_client import InternalClient, UnexpectedResponse
+from swift.common import utils
 from swift.common.utils import get_logger, dump_recon_cache, split_path, \
-    Timestamp, config_true_value, normalize_delete_at_timestamp
+    Timestamp, config_true_value, normalize_delete_at_timestamp, \
+    RateLimitedIterator, md5, non_negative_float, non_negative_int, \
+    parse_content_type, parse_options, config_positive_int_value
 from swift.common.http import HTTP_NOT_FOUND, HTTP_CONFLICT, \
     HTTP_PRECONDITION_FAILED
-from swift.common.swob import wsgi_quote, str_to_wsgi
+from swift.common.recon import RECON_OBJECT_FILE, DEFAULT_RECON_CACHE_PATH
 
 from swift.container.reconciler import direct_delete_container_entry
 
 MAX_OBJECTS_TO_CACHE = 100000
+X_DELETE_TYPE = 'text/plain'
 ASYNC_DELETE_TYPE = 'application/async-deleted'
 
+# expiring_objects_account_name used to be a supported configuration across
+# proxy/expirer configs, but AUTO_CREATE_ACCOUNT_PREFIX is configured in
+# swift.conf constraints; neither should be changed
+EXPIRER_ACCOUNT_NAME = AUTO_CREATE_ACCOUNT_PREFIX + 'expiring_objects'
+# Most clusters use the default "expiring_objects_container_divisor" of 86400
+EXPIRER_CONTAINER_DIVISOR = 86400
+EXPIRER_CONTAINER_PER_DIVISOR = 100
+
+
+class ExpirerConfig(object):
+
+    def __init__(self, conf, container_ring=None, logger=None):
+        """
+        Read the configurable object-expirer values consistently and issue
+        warnings appropriately when we encounter deprecated options.
+
+        This class is used in multiple contexts on proxy and object servers.
+
+        :param conf: a config dictionary
+        :param container_ring: optional, required in proxy context to lookup
+                               task container (part, nodes)
+        :param logger: optional, will create one from the conf if not given
+        """
+        logger = logger or get_logger(conf)
+        if 'expiring_objects_container_divisor' in conf:
+            logger.warning(
+                'expiring_objects_container_divisor is deprecated')
+            expirer_divisor = config_positive_int_value(
+                conf['expiring_objects_container_divisor'])
+        else:
+            expirer_divisor = EXPIRER_CONTAINER_DIVISOR
+
+        if 'expiring_objects_account_name' in conf:
+            logger.warning(
+                'expiring_objects_account_name is deprecated; you need '
+                'to migrate to the standard .expiring_objects account')
+            account_name = (AUTO_CREATE_ACCOUNT_PREFIX +
+                            conf['expiring_objects_account_name'])
+        else:
+            account_name = EXPIRER_ACCOUNT_NAME
+        self.account_name = account_name
+        self.expirer_divisor = expirer_divisor
+        self.task_container_per_day = EXPIRER_CONTAINER_PER_DIVISOR
+        if self.task_container_per_day >= self.expirer_divisor:
+            msg = 'expiring_objects_container_divisor MUST be greater than 100'
+            if self.expirer_divisor != 86400:
+                msg += '; expiring_objects_container_divisor (%s) SHOULD be ' \
+                       'default value of %d' \
+                       % (self.expirer_divisor, EXPIRER_CONTAINER_DIVISOR)
+            raise ValueError(msg)
+        self.container_ring = container_ring
+
+    def get_expirer_container(self, x_delete_at, acc, cont, obj):
+        """
+        Returns an expiring object task container name for given X-Delete-At
+        and (native string) a/c/o.
+        """
+        # offset backwards from the expected day is a hash of size "per day"
+        shard_int = (int(utils.hash_path(acc, cont, obj), 16) %
+                     self.task_container_per_day)
+        # even though the attr is named "task_container_per_day" it's actually
+        # "task_container_per_divisor" if for some reason the deprecated config
+        # "expirer_divisor" option doesn't have the default value of 86400
+        return normalize_delete_at_timestamp(
+            int(x_delete_at) // self.expirer_divisor *
+            self.expirer_divisor - shard_int)
+
+    def get_expirer_account_and_container(self, x_delete_at, acc, cont, obj):
+        """
+        Calculates the expected expirer account and container for the target
+        given the current configuration.
+
+        :returns: a tuple, (account_name, task_container)
+        """
+        task_container = self.get_expirer_container(
+            x_delete_at, acc, cont, obj)
+        return self.account_name, task_container
+
+    def is_expected_task_container(self, task_container_int):
+        """
+        Validate the task_container timestamp as an expected value given the
+        current configuration. Changing the expirer configuration will lead to
+        orphaned x-delete-at task objects on overwrite, which may stick around
+        a whole reclaim age.
+
+        :params task_container_int: an int, all task_containers are expected
+                                    to be integer timestamps
+
+        :returns: a boolean, True if name fits with the given config
+        """
+        # calculate seconds offset into previous divisor window
+        r = (task_container_int - 1) % self.expirer_divisor
+        # seconds offset should be no more than task_container_per_day i.e.
+        # given % 86400, r==86359 is ok (because 41 is less than 100), but
+        # 49768 would be unexpected
+        return self.expirer_divisor - r <= self.task_container_per_day
+
+    def get_delete_at_nodes(self, x_delete_at, acc, cont, obj):
+        """
+        Get the task_container part, nodes, and name.
+
+        :returns: a tuple, (part, nodes, task_container_name)
+        """
+        if not self.container_ring:
+            raise RuntimeError('%s was not created with container_ring' % self)
+        account_name, task_container = self.get_expirer_account_and_container(
+            x_delete_at, acc, cont, obj)
+        part, nodes = self.container_ring.get_nodes(
+            account_name, task_container)
+        return part, nodes, task_container
+
 
 def build_task_obj(timestamp, target_account, target_container,
-                   target_obj):
+                   target_obj, high_precision=False):
     """
     :return: a task object name in format of
              "<timestamp>-<target_account>/<target_container>/<target_obj>"
     """
     timestamp = Timestamp(timestamp)
     return '%s-%s/%s/%s' % (
-        normalize_delete_at_timestamp(timestamp),
+        normalize_delete_at_timestamp(timestamp, high_precision),
         target_account, target_container, target_obj)
 
 
@@ -66,6 +181,80 @@ def parse_task_obj(task_obj):
     return timestamp, target_account, target_container, target_obj
 
 
+def extract_expirer_bytes_from_ctype(content_type):
+    """
+    Parse a content-type and return the number of bytes.
+
+    :param content_type: a content-type string
+    :return: int or None
+    """
+    content_type, params = parse_content_type(content_type)
+    bytes_size = None
+    for k, v in params:
+        if k == 'swift_expirer_bytes':
+            bytes_size = int(v)
+    return bytes_size
+
+
+def embed_expirer_bytes_in_ctype(content_type, metadata):
+    """
+    Embed number of bytes into content-type.  The bytes should come from
+    content-length on regular objects, but future extensions to "bytes in
+    expirer queue" monitoring may want to more closely consider expiration of
+    large multipart object manifests.
+
+    :param content_type: a content-type string
+    :param metadata: a dict, from Diskfile metadata
+    :return: str
+    """
+    # as best I can tell this key is required by df.open
+    report_bytes = metadata['Content-Length']
+    return "%s;swift_expirer_bytes=%d" % (content_type, int(report_bytes))
+
+
+def read_conf_for_delay_reaping_times(conf):
+    delay_reaping_times = {}
+    for conf_key in conf:
+        delay_reaping_prefix = "delay_reaping_"
+        if not conf_key.startswith(delay_reaping_prefix):
+            continue
+        delay_reaping_key = urllib.parse.unquote(
+            conf_key[len(delay_reaping_prefix):])
+        if delay_reaping_key.strip('/') != delay_reaping_key:
+            raise ValueError(
+                '%s '
+                'should be in the form delay_reaping_<account> '
+                'or delay_reaping_<account>/<container> '
+                '(leading or trailing "/" is not allowed)' % conf_key)
+        try:
+            # If split_path fails, have multiple '/' or
+            # account name is invalid
+            account, container = split_path(
+                '/' + delay_reaping_key, 1, 2
+            )
+        except ValueError:
+            raise ValueError(
+                '%s '
+                'should be in the form delay_reaping_<account> '
+                'or delay_reaping_<account>/<container> '
+                '(at most one "/" is allowed)' % conf_key)
+        try:
+            delay_reaping_times[(account, container)] = non_negative_float(
+                conf.get(conf_key)
+            )
+        except ValueError:
+            raise ValueError(
+                '%s must be a float '
+                'greater than or equal to 0' % conf_key)
+    return delay_reaping_times
+
+
+def get_delay_reaping(delay_reaping_times, target_account, target_container):
+    return delay_reaping_times.get(
+        (target_account, target_container),
+        delay_reaping_times.get((target_account, None), 0.0))
+
+
 class ObjectExpirer(Daemon):
     """
     Daemon that queries the internal hidden task accounts to discover objects
@@ -73,11 +262,14 @@ class ObjectExpirer(Daemon):
 
     :param conf: The daemon configuration.
     """
+    log_route = 'object-expirer'
 
     def __init__(self, conf, logger=None, swift=None):
         self.conf = conf
-        self.logger = logger or get_logger(conf, log_route='object-expirer')
-        self.interval = int(conf.get('interval') or 300)
+        self.logger = logger or get_logger(conf, log_route=self.log_route)
+        self.interval = float(conf.get('interval') or 300)
+        self.tasks_per_second = float(conf.get('tasks_per_second', 50.0))
+        self.expirer_config = ExpirerConfig(conf, logger=self.logger)
 
         self.conf_path = \
             self.conf.get('__file__') or '/etc/swift/object-expirer.conf'
@@ -87,22 +279,14 @@ class ObjectExpirer(Daemon):
         self.dequeue_from_legacy = \
             True if is_legacy_conf else \
             config_true_value(conf.get('dequeue_from_legacy', 'false'))
-
-        if is_legacy_conf:
-            self.ic_conf_path = self.conf_path
-        else:
-            self.ic_conf_path = \
-                self.conf.get('internal_client_conf_path') or \
-                '/etc/swift/internal-client.conf'
-
-        self.read_conf_for_queue_access(swift)
-
-        self.report_interval = int(conf.get('report_interval') or 300)
+        self.swift = swift or self._make_internal_client(is_legacy_conf)
+        self.read_conf_for_queue_access()
+        self.report_interval = float(conf.get('report_interval') or 300)
         self.report_first_time = self.report_last_time = time()
         self.report_objects = 0
         self.recon_cache_path = conf.get('recon_cache_path',
-                                         '/var/cache/swift')
-        self.rcache = join(self.recon_cache_path, 'object.recon')
+                                         DEFAULT_RECON_CACHE_PATH)
+        self.rcache = join(self.recon_cache_path, RECON_OBJECT_FILE)
         self.concurrency = int(conf.get('concurrency', 1))
         if self.concurrency < 1:
             raise ValueError("concurrency must be set to at least 1")
@@ -111,21 +295,33 @@ class ObjectExpirer(Daemon):
         # with the tombstone reclaim age in the consistency engine.
         self.reclaim_age = int(conf.get('reclaim_age', 604800))
 
-    def read_conf_for_queue_access(self, swift):
-        self.expiring_objects_account = \
-            (self.conf.get('auto_create_account_prefix') or '.') + \
+        self.delay_reaping_times = read_conf_for_delay_reaping_times(conf)
+        self.round_robin_task_cache_size = int(
+            conf.get('round_robin_task_cache_size', MAX_OBJECTS_TO_CACHE))
+
+    def _make_internal_client(self, is_legacy_conf):
+        default_ic_conf_path = '/etc/swift/internal-client.conf'
+        if is_legacy_conf:
+            default_ic_conf_path = self.conf_path
+        ic_conf_path = self.conf.get(
+            'internal_client_conf_path', default_ic_conf_path)
+        request_tries = int(self.conf.get('request_tries') or 3)
+        return InternalClient(
+            ic_conf_path, 'Swift Object Expirer', request_tries,
+            use_replication_network=True,
+            global_conf={'log_name': '%s-ic' % self.conf.get(
+                'log_name', self.log_route)})
+
+    def read_conf_for_queue_access(self):
+        self.expiring_objects_account = AUTO_CREATE_ACCOUNT_PREFIX + \
             (self.conf.get('expiring_objects_account_name') or
              'expiring_objects')
 
         # This is for common parameter with general task queue in future
         self.task_container_prefix = ''
-
-        request_tries = int(self.conf.get('request_tries') or 3)
-        self.swift = swift or InternalClient(
-            self.ic_conf_path, 'Swift Object Expirer', request_tries)
-
-        self.processes = int(self.conf.get('processes', 0))
-        self.process = int(self.conf.get('process', 0))
+        self.processes = non_negative_int(self.conf.get('processes', 0))
+        self.process = non_negative_int(self.conf.get('process', 0))
+        self._validate_processes_config()
 
     def report(self, final=False):
         """
@@ -137,17 +333,17 @@ class ObjectExpirer(Daemon):
         """
         if final:
             elapsed = time() - self.report_first_time
-            self.logger.info(_('Pass completed in %(time)ds; '
-                               '%(objects)d objects expired') % {
-                             'time': elapsed, 'objects': self.report_objects})
+            self.logger.info(
+                'Pass completed in %(time)ds; %(objects)d objects expired', {
+                    'time': elapsed, 'objects': self.report_objects})
             dump_recon_cache({'object_expiration_pass': elapsed,
                               'expired_last_pass': self.report_objects},
                              self.rcache, self.logger)
         elif time() - self.report_last_time >= self.report_interval:
             elapsed = time() - self.report_first_time
-            self.logger.info(_('Pass so far %(time)ds; '
-                               '%(objects)d objects expired') % {
-                             'time': elapsed, 'objects': self.report_objects})
+            self.logger.info(
+                'Pass so far %(time)ds; %(objects)d objects expired', {
+                    'time': elapsed, 'objects': self.report_objects})
             self.report_last_time = time()
 
     def parse_task_obj(self, task_obj):
@@ -186,7 +382,7 @@ class ObjectExpirer(Daemon):
             obj_cache[cache_key].append(delete_task)
             cnt += 1
 
-            if cnt > MAX_OBJECTS_TO_CACHE:
+            if cnt > self.round_robin_task_cache_size:
                 for task in dump_obj_cache_in_round_robin():
                     yield task
                 cnt = 0
@@ -203,7 +399,8 @@ class ObjectExpirer(Daemon):
         if not isinstance(name, bytes):
             name = name.encode('utf8')
         # md5 is only used for shuffling mod
-        return int(hashlib.md5(name).hexdigest(), 16) % divisor
+        return int(md5(
+            name, usedforsecurity=False).hexdigest(), 16) % divisor
 
     def iter_task_accounts_to_expire(self):
         """
@@ -217,29 +414,112 @@ class ObjectExpirer(Daemon):
         only one expirer.
         """
         if self.processes > 0:
-            yield self.expiring_objects_account, self.process, self.processes
+            yield (self.expirer_config.account_name,
+                   self.process, self.processes)
         else:
-            yield self.expiring_objects_account, 0, 1
-
-    def delete_at_time_of_task_container(self, task_container):
-        """
-        get delete_at timestamp from task_container name
-        """
-        # task_container name is timestamp
-        return Timestamp(task_container)
+            yield self.expirer_config.account_name, 0, 1
 
-    def iter_task_containers_to_expire(self, task_account):
+    def get_task_containers_to_expire(self, task_account):
         """
-        Yields task_container names under the task_account if the delete at
+        Collects task_container names under the task_account if the delete at
         timestamp of task_container is past.
         """
+        container_list = []
+        unexpected_task_containers = {
+            'examples': [],
+            'count': 0,
+        }
         for c in self.swift.iter_containers(task_account,
                                             prefix=self.task_container_prefix):
-            task_container = str(c['name'])
-            timestamp = self.delete_at_time_of_task_container(task_container)
-            if timestamp > Timestamp.now():
+            try:
+                task_container_int = int(Timestamp(c['name']))
+            except ValueError:
+                self.logger.error('skipping invalid task container: %s/%s',
+                                  task_account, c['name'])
+                continue
+            if not self.expirer_config.is_expected_task_container(
+                    task_container_int):
+                unexpected_task_containers['count'] += 1
+                if unexpected_task_containers['count'] < 5:
+                    unexpected_task_containers['examples'].append(c['name'])
+            if task_container_int > Timestamp.now():
+                break
+            container_list.append(str(task_container_int))
+
+        if unexpected_task_containers['count']:
+            self.logger.info(
+                'processing %s unexpected task containers (e.g. %s)',
+                unexpected_task_containers['count'],
+                ' '.join(unexpected_task_containers['examples']))
+        return container_list
+
+    def get_delay_reaping(self, target_account, target_container):
+        return get_delay_reaping(self.delay_reaping_times, target_account,
+                                 target_container)
+
+    def _iter_task_container(self, task_account, task_container,
+                             my_index, divisor):
+        """
+        Iterates the input task container, yields a task expire info dict for
+        each delete task if it is assigned to this expirer process.
+
+        :raises UnexpectedResponse: if the task container listing is not
+            successful.
+        """
+        container_empty = True
+        for o in self.swift.iter_objects(task_account,
+                                         task_container,
+                                         acceptable_statuses=[2]):
+            container_empty = False
+            task_object = o['name']
+            try:
+                delete_timestamp, target_account, target_container, \
+                    target_object = parse_task_obj(task_object)
+            except ValueError:
+                self.logger.exception('Unexcepted error handling task %r' %
+                                      task_object)
+                self.logger.increment('tasks.parse_errors')
+                continue
+            is_async = o.get('content_type') == ASYNC_DELETE_TYPE
+            delay_reaping = self.get_delay_reaping(target_account,
+                                                   target_container)
+
+            if delete_timestamp > Timestamp.now():
+                # we shouldn't yield ANY more objects that can't reach
+                # the expiration date yet.
                 break
-            yield task_container
+
+            # Only one expirer daemon assigned for each task
+            if self.hash_mod('%s/%s' % (task_container, task_object),
+                             divisor) != my_index:
+                self.logger.increment('tasks.skipped')
+                continue
+
+            if delete_timestamp > Timestamp(time() - delay_reaping) \
+                    and not is_async:
+                # we shouldn't yield the object during the delay
+                self.logger.increment('tasks.delayed')
+                continue
+
+            self.logger.increment('tasks.assigned')
+            yield {'task_account': task_account,
+                   'task_container': task_container,
+                   'task_object': task_object,
+                   'target_path': '/'.join([
+                       target_account, target_container, target_object]),
+                   'delete_timestamp': delete_timestamp,
+                   'is_async_delete': is_async}
+        if container_empty:
+            try:
+                self.swift.delete_container(
+                    task_account, task_container,
+                    acceptable_statuses=(2, HTTP_NOT_FOUND, HTTP_CONFLICT))
+            except (Exception, Timeout) as err:
+                self.logger.exception(
+                    'Exception while deleting container %(account)s '
+                    '%(container)s %(err)s', {
+                        'account': task_account,
+                        'container': task_container, 'err': str(err)})
 
     def iter_task_to_expire(self, task_account_container_list,
                             my_index, divisor):
@@ -248,36 +528,27 @@ class ObjectExpirer(Daemon):
         task_container, task_object, timestamp_to_delete, and target_path
         """
         for task_account, task_container in task_account_container_list:
-            for o in self.swift.iter_objects(task_account, task_container):
-                if six.PY2:
-                    task_object = o['name'].encode('utf8')
-                else:
-                    task_object = o['name']
-                try:
-                    delete_timestamp, target_account, target_container, \
-                        target_object = parse_task_obj(task_object)
-                except ValueError:
-                    self.logger.exception('Unexcepted error handling task %r' %
-                                          task_object)
-                    continue
-                if delete_timestamp > Timestamp.now():
-                    # we shouldn't yield the object that doesn't reach
-                    # the expiration date yet.
-                    break
-
-                # Only one expirer daemon assigned for one task
-                if self.hash_mod('%s/%s' % (task_container, task_object),
-                                 divisor) != my_index:
-                    continue
-
-                is_async = o.get('content_type') == ASYNC_DELETE_TYPE
-                yield {'task_account': task_account,
-                       'task_container': task_container,
-                       'task_object': task_object,
-                       'target_path': '/'.join([
-                           target_account, target_container, target_object]),
-                       'delete_timestamp': delete_timestamp,
-                       'is_async_delete': is_async}
+            try:
+                for item in self._iter_task_container(
+                        task_account, task_container, my_index, divisor):
+                    yield item
+            except UnexpectedResponse as err:
+                if err.resp.status_int != 404:
+                    self.logger.error(
+                        'Unexpected response while listing objects in '
+                        'container %(account)s %(container)s: %(err)s', {
+                            'account': task_account,
+                            'container': task_container,
+                            'err': str(err)
+                        })
+            except (Exception, Timeout) as err:
+                self.logger.error(
+                    'Exception while listing objects in container %(account)s '
+                    '%(container)s: %(err)s', {
+                        'account': task_account,
+                        'container': task_container,
+                        'err': str(err)
+                    })
 
     def run_once(self, *args, **kwargs):
         """
@@ -290,6 +561,9 @@ class ObjectExpirer(Daemon):
                        These will override the values from the config file if
                        provided.
         """
+        # these config values are available to override at the command line,
+        # blow-up now if they're wrong
+        self.override_proceses_config_from_command_line(**kwargs)
         # This if-clause will be removed when general task queue feature is
         # implemented.
         if not self.dequeue_from_legacy:
@@ -300,13 +574,11 @@ class ObjectExpirer(Daemon):
                              'with dequeue_from_legacy == true.')
             return
 
-        self.get_process_values(kwargs)
         pool = GreenPool(self.concurrency)
         self.report_first_time = self.report_last_time = time()
         self.report_objects = 0
         try:
             self.logger.debug('Run begin')
-            task_account_container_list_to_delete = list()
             for task_account, my_index, divisor in \
                     self.iter_task_accounts_to_expire():
                 container_count, obj_count = \
@@ -316,20 +588,17 @@ class ObjectExpirer(Daemon):
                 if not container_count:
                     continue
 
-                self.logger.info(_(
+                self.logger.info(
                     'Pass beginning for task account %(account)s; '
                     '%(container_count)s possible containers; '
-                    '%(obj_count)s possible objects') % {
-                    'account': task_account,
-                    'container_count': container_count,
-                    'obj_count': obj_count})
+                    '%(obj_count)s possible objects', {
+                        'account': task_account,
+                        'container_count': container_count,
+                        'obj_count': obj_count})
 
                 task_account_container_list = \
                     [(task_account, task_container) for task_container in
-                     self.iter_task_containers_to_expire(task_account)]
-
-                task_account_container_list_to_delete.extend(
-                    task_account_container_list)
+                     self.get_task_containers_to_expire(task_account)]
 
                 # delete_task_iter is a generator to yield a dict of
                 # task_account, task_container, task_object, delete_timestamp,
@@ -338,27 +607,17 @@ class ObjectExpirer(Daemon):
                 delete_task_iter = \
                     self.round_robin_order(self.iter_task_to_expire(
                         task_account_container_list, my_index, divisor))
-
-                for delete_task in delete_task_iter:
+                rate_limited_iter = RateLimitedIterator(
+                    delete_task_iter,
+                    elements_per_second=self.tasks_per_second)
+                for delete_task in rate_limited_iter:
                     pool.spawn_n(self.delete_object, **delete_task)
 
             pool.waitall()
-            for task_account, task_container in \
-                    task_account_container_list_to_delete:
-                try:
-                    self.swift.delete_container(
-                        task_account, task_container,
-                        acceptable_statuses=(2, HTTP_NOT_FOUND, HTTP_CONFLICT))
-                except (Exception, Timeout) as err:
-                    self.logger.exception(
-                        _('Exception while deleting container %(account)s '
-                          '%(container)s %(err)s') % {
-                              'account': task_account,
-                              'container': task_container, 'err': str(err)})
             self.logger.debug('Run end')
             self.report(final=True)
         except (Exception, Timeout):
-            self.logger.exception(_('Unhandled exception'))
+            self.logger.exception('Unhandled exception')
 
     def run_forever(self, *args, **kwargs):
         """
@@ -369,18 +628,21 @@ class ObjectExpirer(Daemon):
         :param kwargs: Extra keyword args to fulfill the Daemon interface; this
                        daemon has no additional keyword args.
         """
+        # these config values are available to override at the command line
+        # blow-up now if they're wrong
+        self.override_proceses_config_from_command_line(**kwargs)
         sleep(random() * self.interval)
         while True:
             begin = time()
             try:
                 self.run_once(*args, **kwargs)
             except (Exception, Timeout):
-                self.logger.exception(_('Unhandled exception'))
+                self.logger.exception('Unhandled exception')
             elapsed = time() - begin
             if elapsed < self.interval:
                 sleep(random() * (self.interval - elapsed))
 
-    def get_process_values(self, kwargs):
+    def override_proceses_config_from_command_line(self, **kwargs):
         """
         Sets self.processes and self.process from the kwargs if those
         values exist, otherwise, leaves those values as they were set in
@@ -391,19 +653,20 @@ class ObjectExpirer(Daemon):
                        line when the daemon is run.
         """
         if kwargs.get('processes') is not None:
-            self.processes = int(kwargs['processes'])
+            self.processes = non_negative_int(kwargs['processes'])
 
         if kwargs.get('process') is not None:
-            self.process = int(kwargs['process'])
+            self.process = non_negative_int(kwargs['process'])
 
-        if self.process < 0:
-            raise ValueError(
-                'process must be an integer greater than or equal to 0')
+        self._validate_processes_config()
 
-        if self.processes < 0:
-            raise ValueError(
-                'processes must be an integer greater than or equal to 0')
+    def _validate_processes_config(self):
+        """
+        Used in constructor and in override_proceses_config_from_command_line
+        to validate the processes configuration requirements.
 
+        :raiess: ValueError if processes config is invalid
+        """
         if self.processes and self.process >= self.processes:
             raise ValueError(
                 'process must be less than processes')
@@ -469,7 +732,6 @@ class ObjectExpirer(Daemon):
         :raises UnexpectedResponse: if the delete was unsuccessful and
                                     should be retried later
         """
-        path = '/v1/' + wsgi_quote(str_to_wsgi(actual_obj.lstrip('/')))
         if is_async_delete:
             headers = {'X-Timestamp': timestamp.normal}
             acceptable_statuses = (2, HTTP_CONFLICT, HTTP_NOT_FOUND)
@@ -478,4 +740,24 @@ class ObjectExpirer(Daemon):
                        'X-If-Delete-At': timestamp.normal,
                        'X-Backend-Clean-Expiring-Object-Queue': 'no'}
             acceptable_statuses = (2, HTTP_CONFLICT)
-        self.swift.make_request('DELETE', path, headers, acceptable_statuses)
+        self.swift.delete_object(*split_path('/' + actual_obj, 3, 3, True),
+                                 headers=headers,
+                                 acceptable_statuses=acceptable_statuses)
+
+
+def main():
+    parser = OptionParser("%prog CONFIG [options]")
+    parser.add_option('--processes', dest='processes',
+                      help="Number of processes to use to do the work, don't "
+                      "use this option to do all the work in one process")
+    parser.add_option('--process', dest='process',
+                      help="Process number for this process, don't use "
+                      "this option to do all the work in one process, this "
+                      "is used to determine which part of the work this "
+                      "process should do")
+    conf_file, options = parse_options(parser=parser, once=True)
+    run_daemon(ObjectExpirer, conf_file, **options)
+
+
+if __name__ == '__main__':
+    main()