101 lines
2.8 KiB
Python
101 lines
2.8 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
"""
|
|
schedule.pypopush
|
|
~~~~~~~~~
|
|
|
|
Purpose of pypopush is to separate the schedule into items currently
|
|
scheduled and scheduled in the future. Currently scheduled items are
|
|
handled immediately, and future scheduled items are handed off to
|
|
PypoLiqQueue
|
|
|
|
:author: (c) 2012 by Martin Konecny.
|
|
:license: GPLv3, see LICENSE for more details.
|
|
"""
|
|
|
|
from datetime import datetime
|
|
from datetime import timedelta
|
|
from threading import Thread
|
|
from Queue import Queue
|
|
|
|
import logging.config
|
|
import math
|
|
import traceback
|
|
import os
|
|
|
|
from pypoliqqueue import PypoLiqQueue
|
|
from schedule import pure
|
|
from api_clients import api_client
|
|
from std_err_override import LogWriter
|
|
|
|
# configure logging
|
|
logging_cfg = os.path.join(os.path.dirname(__file__), "../configs/logging.cfg")
|
|
logging.config.fileConfig(logging_cfg)
|
|
logger = logging.getLogger()
|
|
LogWriter.override_std_err(logger)
|
|
|
|
class PypoPush(Thread):
|
|
def __init__(self, q, pypo_liquidsoap):
|
|
Thread.__init__(self)
|
|
self.api_client = api_client.AirtimeApiClient()
|
|
self.queue = q
|
|
|
|
self.logger = logging.getLogger('push')
|
|
|
|
self.future_scheduled_queue = Queue()
|
|
self.pypo_liquidsoap = pypo_liquidsoap
|
|
|
|
self.plq = PypoLiqQueue(self.future_scheduled_queue, \
|
|
self.pypo_liquidsoap, \
|
|
self.logger)
|
|
self.plq.daemon = True
|
|
self.plq.start()
|
|
|
|
|
|
def main(self):
|
|
media_schedule = None
|
|
|
|
while True:
|
|
try:
|
|
media_schedule = self.queue.get(block=True)
|
|
except Exception, e:
|
|
self.logger.error(str(e))
|
|
raise
|
|
else:
|
|
self.logger.debug(media_schedule)
|
|
#separate media_schedule list into currently_playing and
|
|
#scheduled_for_future lists
|
|
currently_playing, scheduled_for_future = \
|
|
self.separate_present_future(media_schedule)
|
|
|
|
self.pypo_liquidsoap.verify_correct_present_media(
|
|
currently_playing)
|
|
self.future_scheduled_queue.put(scheduled_for_future)
|
|
|
|
def separate_present_future(self, media_schedule):
|
|
tnow = datetime.utcnow()
|
|
|
|
present = []
|
|
future = {}
|
|
|
|
sorted_keys = sorted(media_schedule.keys())
|
|
for mkey in sorted_keys:
|
|
media_item = media_schedule[mkey]
|
|
|
|
diff_td = tnow - media_item['start']
|
|
diff_sec = pure.date_interval_to_seconds(diff_td)
|
|
|
|
if diff_sec >= 0:
|
|
present.append(media_item)
|
|
else:
|
|
future[media_item['start']] = media_item
|
|
|
|
return present, future
|
|
|
|
def run(self):
|
|
try: self.main()
|
|
except Exception, e:
|
|
top = traceback.format_exc()
|
|
self.logger.error('Pypo Push Exception: %s', top)
|
|
|