def dequeue(self, queued_signal=None):
""" Deserialize and execute a signal, either from the queue or as per the contents
of the queued_signal kwarg.
If queued_signal contains a serialized signal call datastructure,* dequeue()
will deserialize and execute that serialized signal without popping the queue.
If queued_signal is None, it will call retrieve() to pop the queue for the next
signal, which it will execute if one is returned successfully.
* See the QueueBase docstring for an example. """
from django.db.models.loading import cache
if queued_signal is None:
queued_signal = self.retrieve()
if queued_signal is not None:
logg.debug("Dequeueing signal: %s" % queued_signal)
pass
else:
return (None, None)
signal_dict = queued_signal.get('signal')
sender_dict = queued_signal.get('sender')
regkey, name = signal_dict.items()[0]
sender = None
# specifying a sender is optional.
if sender_dict is not None:
try:
sender = cache.get_model(str(sender_dict['app_label']),
str(sender_dict['modl_name']))
except (KeyError, AttributeError), err:
logg.info("*** Error deserializing sender_dict: %s" % err)
sender = None
def main():
logg = logging.getLogger("signalqueue")
# Set up color if we are in a tty and curses is installed
color = False
if curses and sys.stderr.isatty():
try:
curses.setupterm()
if curses.tigetnum("colors") > 0:
color = True
except:
pass
channel = logging.StreamHandler()
channel.setFormatter(_LogFormatter(color=color))
logg.addHandler(channel)
logg.info("YO DOGG.")
from django.conf import settings
try:
tornado.options.parse_command_line()
http_server = HTTPServer(Application())
http_server.listen(settings.SQ_WORKER_PORT)
IOLoop.instance().start()
except KeyboardInterrupt:
print 'NOOOOOOOOOOOO DOGGGGG!!!'
def dequeue(self, queued_signal=None):
"""
Deserialize and execute a signal, either from the queue or as per the contents
of the queued_signal kwarg.
If queued_signal contains a serialized signal call datastructure,* dequeue()
will deserialize and execute that serialized signal without popping the queue.
If queued_signal is None, it will call retrieve() to pop the queue for the next
signal, which it will execute if one is returned successfully.
* See the QueueBase docstring for an example.
"""
if queued_signal is None:
queued_signal = self.retrieve()
logg.info("Dequeueing signal: %s" % queued_signal)
signal_dict = queued_signal.get('signal')
sender_dict = queued_signal.get('sender')
regkey, name = signal_dict.items()[0]
sender = None
# specifying a sender is optional.
if sender_dict is not None:
try:
sender = cache.get_model(str(sender_dict['app_label']), str(sender_dict['modl_name']))
except (KeyError, AttributeError), err:
sender = None
def send(self, sender, **named):
from signalqueue.worker import queues
self.runmode = int(named.pop("runmode", queues._runmode))
logg.debug("--- send() called, runmode = %s" % self.runmode)
if self.runmode:
if self.runmode == runmodes["SQ_ASYNC_REQUEST"]:
# it's a web request -- enqueue it
return self.enqueue(sender, **named)
elif self.runmode == runmodes["SQ_ASYNC_DAEMON"]:
# signal sent in daemon mode -- enqueue it
return self.enqueue(sender, **named)
elif self.runmode == runmodes["SQ_ASYNC_MGMT"]:
# signal sent in command mode -- fire away
return self.send_now(sender, **named)
elif self.runmode == runmodes["SQ_SYNC"]:
# fire normally
return self.send_now(sender, **named)
else:
# unknown runmode value -- fire normally
logg.info("*** send() called with an unknown runmode: '%s' -- firing sync signal." % self.runmode)
return self.send_now(sender, **named)
else:
# fire normally
logg.info("*** send() called and no runmode configured -- firing sync signal.")
return self.send_now(sender, **named)
def send(self, sender, **named):
from signalqueue import SQ_RUNMODES as runmodes
from signalqueue.worker import queues
from signalqueue.utils import logg
self.runmode = int(named.pop('runmode', queues._runmode))
#logg.debug("--- send() called, runmode = %s" % self.runmode)
if self.runmode:
if self.runmode == runmodes['SQ_ASYNC_REQUEST']:
# it's a web request -- enqueue it
return self.enqueue(sender, **named)
elif self.runmode == runmodes['SQ_ASYNC_DAEMON']:
# signal sent in daemon mode -- enqueue it
return self.enqueue(sender, **named)
elif self.runmode == runmodes['SQ_ASYNC_MGMT']:
# signal sent in command mode -- fire away
return self.send_now(sender, **named)
elif self.runmode == runmodes['SQ_SYNC']:
# fire normally
return self.send_now(sender, **named)
else:
# unknown runmode value -- fire normally
logg.info(
"*** send() called with an unknown runmode: '%s' -- firing sync signal." % self.runmode)
return self.send_now(sender, **named)
else:
# fire normally
logg.info("*** send() called and no runmode configured -- firing sync signal.")
return self.send_now(sender, **named)
def eightball_scratch(self):
with self.signalqueue.log_exceptions():
self.signalqueue.dequeue()
if self.signalqueue.count() < 1:
logg.info("Queue exhausted, exiting...")
raise KeyboardInterrupt
def cueball_scratch(self):
try:
self.signalqueue.dequeue()
except Exception, err:
logg.info("--- Exception during dequeue: %s" % err)
""" Non-logging cues """
def cueball(self):
try:
self.signalqueue.dequeue()
except Exception, err:
logg.info("--- Exception during dequeue: %s" % err)
def cueball_scratch(self):
try:
self.signalqueue.dequeue()
except Exception, err:
logg.info("--- Exception during dequeue: %s" % err)
if self.signalqueue.count() < 1:
logg.info("Queue exhausted, exiting...")
raise KeyboardInterrupt
""" Logging cues """
def eightball(self):
with self.signalqueue.log_exceptions():
self.signalqueue.dequeue()
def eightball_scratch(self):
with self.signalqueue.log_exceptions():
self.signalqueue.dequeue()
if self.signalqueue.count() < 1:
logg.info("Queue exhausted, exiting...")
raise KeyboardInterrupt
