Esempio n. 1
0
 def __init__(self, channel, prefetch_count=None, interval=None,
         do_restore=True):
     self.channel = channel
     self.prefetch_count = prefetch_count
     self.interval = interval
     self._delivered = OrderedDict()
     self.do_restore = do_restore
     self._restored_once = False
     if self.do_restore:
         atexit.register(self.restore_unacked_once)
Esempio n. 2
0
class QualityOfService(object):

    def __init__(self, channel, prefetch_count=None, interval=None,
            do_restore=True):
        self.channel = channel
        self.prefetch_count = prefetch_count
        self.interval = interval
        self._delivered = OrderedDict()
        self.do_restore = do_restore
        self._restored_once = False
        if self.do_restore:
            atexit.register(self.restore_unacked_once)

    def can_consume(self):
        if not self.prefetch_count:
            return True
        return len(self._delivered) < self.prefetch_count

    def append(self, message, delivery_tag):
        self._delivered[delivery_tag] = message

    def ack(self, delivery_tag):
        self._delivered.pop(delivery_tag, None)

    def restore_unacked(self):
        for message in self._delivered.items():
            self.channel._restore(message)
        self._delivered.clear()

    def requeue(self, delivery_tag):
        try:
            message = self._delivered.pop(delivery_tag)
        except KeyError:
            pass
        self.channel._restore(message)

    def restore_unacked_once(self):
        if self.do_restore and not self._restored_once:
            if self._delivered:
                sys.stderr.write(
                    "Restoring unacknowledged messages: %s\n" % (
                    self._delivered))
            try:
                self.restore_unacked()
            except:
                pass
            if self._delivered:
                sys.stderr.write("UNABLE TO RESTORE %s MESSAGES\n" % (
                    len(self._delivered)))
                persist = tempfile.mktemp()
                sys.stderr.write(
                    "PERSISTING UNRESTORED MESSAGES TO FILE: %s\n" % persist)
                fh = open(persist, "w")
                try:
                    pickle.dump(self._delivered, fh, protocol=0)
                finally:
                    fh.flush()
                    fh.close()