def push(self, item, pipeline, first_ts=None, ttl=None, envelope=None,
max_attempts=None, attempts=0, error_classes=None, delay=None):
envelope = {'first_ts': first_ts or (envelope and envelope['first_ts'])
or time.time(),
'ts': time.time(),
'item': item,
'v': self.version,
'ttl': ttl,
'attempts': attempts,
'max_attempts': max_attempts or self._max_attempts,
'error_classes': pickle.dumps(error_classes)}
serialized_envelope = self._serializer.serialize(envelope)
if delay is not None:
timestamp = time.time() + delay
key = uuid.uuid1()
pipeline.hset(self._payload_key(), key, serialized_envelope)
compatible_zadd(pipeline, self._delayed_queue_key(), timestamp, key)
else:
if self.mode == self.FIFO:
pipeline.lpush(self._queue_key(), serialized_envelope)
else:
pipeline.rpush(self._queue_key(), serialized_envelope)
self._event_registrar.on_push(
item=item,
item_key=self.item_key(item),
pipeline=pipeline,
pretty_printed_item=self.pretty_printer(item),
delay=delay)
def push(self, item, pipeline=None, when=None, envelope=None,
max_attempts=None, attempts=None, error_classes=None):
passed_pipeline = True
if not pipeline:
passed_pipeline = False
pipeline = self.redis.pipeline()
when = when or (envelope and envelope['when']) or time.time()
attempts = attempts or (envelope and envelope['attempts']) or 0
timestamp = self._get_timestamp(when)
envelope = {'when': timestamp,
'ts': time.time(),
'first_ts': time.time(),
'item': item,
'ttl': None,
'v': 1,
'attempts': attempts,
'max_attempts': max_attempts or self._max_attempts,
'error_classes': pickle.dumps(error_classes)}
key = self.item_key(item)
pipeline.hset(self._payload_key(), key,
self._serializer.serialize(envelope))
compatible_zadd(pipeline, self._queue_key(), timestamp, key)
self._event_registrar.on_push(
item=item,
item_key=key,
pipeline=pipeline,
pretty_printed_item=self.pretty_printer(item))
if passed_pipeline:
return None
return_values = pipeline.execute()
was_new_item = return_values[0] #this is the hset
return was_new_item
