When I first posted patches to achieve multiple concurrent recordings I
said that there were a few desired features not yet implemented. These
included better conflict resolution and 2 programs starting at the same
time.
The attached helpers/recordserver.py fixes that. (based on 1.6.1 I believe)
The only assumptions this code makes is that all entries in VIDEO_GROUPS
are of the same type (I use it with ivtv) and are able to record the
same channels (I currently use a PVR500).
have fun!
Paul
--
Paul Sijben mailto:[EMAIL PROTECTED]
Amersfoort, NL http://www.sijben.net
tel:+31 334557522 fax:+31 33 4557523
#!/usr/bin/env python
# -*- coding: iso-8859-1 -*-
# -----------------------------------------------------------------------
# record_server.py - A network aware TV recording server.
# -----------------------------------------------------------------------
# $Id: recordserver.py 8569 2006-11-11 11:29:08Z duncan $
#
# -----------------------------------------------------------------------
# Freevo - A Home Theater PC framework
# Copyright (C) 2002 Krister Lagerstrom, et al.
# Please see the file freevo/Docs/CREDITS for a complete list of authors.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of MER-
# CHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
# Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# -----------------------------------------------------------------------
import sys, string, random, time, os, re, pwd, stat, threading
import config
from util import vfs
# change uid
if __name__ == '__main__':
try:
if config.TV_RECORD_SERVER_UID and os.getuid() == 0:
os.setgid(config.TV_RECORD_SERVER_GID)
os.setuid(config.TV_RECORD_SERVER_UID)
os.environ['USER'] = pwd.getpwuid(os.getuid())[0]
os.environ['HOME'] = pwd.getpwuid(os.getuid())[5]
except Exception, e:
print e
from twisted.web import xmlrpc, server
from twisted.internet.app import Application
from twisted.internet import reactor
from twisted.python import log
from util.marmalade import jellyToXML, unjellyFromXML
import rc
rc_object = rc.get_singleton(use_pylirc=0, use_netremote=0)
from tv.record_types import TYPES_VERSION
from tv.record_types import ScheduledRecordings
import tv.record_types
import tv.epg_xmltv
import util.tv_util as tv_util
import plugin
import util.popen3
from tv.channels import FreevoChannels
from util.videothumb import snapshot
from event import *
DEBUG = config.DEBUG
def _debug_(text, level=1):
if DEBUG >= level:
try:
log.debug(String(text))
except:
log.debug('Failed to log a message')
_debug_('PLUGIN_RECORD: %s' % config.plugin_record)
appname = os.path.splitext(os.path.basename(sys.argv[0]))[0]
logfile = '%s/%s-%s.log' % (config.LOGDIR, appname, os.getuid())
log.startLogging(open(logfile, 'a'))
plugin.init_special_plugin(config.plugin_record)
if config.TV_RECORD_PADDING_PRE == None:
config.TV_RECORD_PADDING_PRE = config.TV_RECORD_PADDING
if config.TV_RECORD_PADDING_POST == None:
config.TV_RECORD_PADDING_POST = config.TV_RECORD_PADDING
def print_plugin_warning():
print '*************************************************'
print '** Warning: No recording plugin registered. **'
print '** Check your local_conf.py for a **'
print '** bad "plugin_record =" line or **'
print '** this log for a plugin failure. **'
print '** Recordings will fail! **'
print '*************************************************'
if not plugin.getbyname('RECORD'):
print_plugin_warning()
class RecordServer(xmlrpc.XMLRPC):
def __init__(self):
self.lock = threading.Lock()
self.fc = FreevoChannels()
# XXX: In the future we should have one lock per VideoGroup.
self.tv_lock_file = None
self.vg = None
self.cardrecording=[]
for i in range(len(config.VIDEO_GROUPS)):
self.cardrecording.append("")
def isRecording(self):
_debug_('in isRecording', 3)
return glob.glob(config.FREEVO_CACHEDIR + '/record.*') and TRUE or FALSE
def progsTimeCompare(self, first, second):
t1 = first.split(':')[-1]
t2 = second.split(':')[-1]
try:
return int(t1) - int(t2)
except ArithmeticError:
pass
return 0
def findNextProgram(self):
_debug_('in findNextProgram', 3)
next_program = None
progs = self.getScheduledRecordings().getProgramList()
proglist = list(progs)
proglist.sort(self.progsTimeCompare)
now = time.time()
for progitem in proglist:
prog = progs[progitem]
_debug_('%s' % (prog), 2)
try:
recording = prog.isRecording
except:
recording = FALSE
_debug_('%s: recording=%s' % (prog.title, recording))
if now >= prog.stop + config.TV_RECORD_PADDING_POST:
_debug_('%s: prog.stop=%s, now=%s' % (prog.title, \
time.localtime(prog.stop+config.TV_RECORD_PADDING_POST), now), 2)
continue
_debug_('%s: prog.stop=%s' % (prog.title, time.localtime(prog.stop)))
if not recording:
next_program = prog
break
self.next_program = next_program
if next_program == None:
_debug_('No program scheduled to record')
return None
_debug_('%s' % (next_program))
return next_program
def isPlayerRunning(self):
'''
returns the state of a player, mplayer, xine, etc.
TODO:
real player running test, check /dev/videoX.
this could go into the upsoon client
'''
_debug_('in isPlayerRunning', 3)
return (os.path.exists(config.FREEVO_CACHEDIR + '/playing'))
# note: add locking and r/rw options to get/save funs
def getScheduledRecordings(self):
file_ver = None
scheduledRecordings = None
if os.path.isfile(config.TV_RECORD_SCHEDULE):
_debug_('GET: reading cached file (%s)' % config.TV_RECORD_SCHEDULE, 2)
if hasattr(self, 'scheduledRecordings_cache'):
mod_time, scheduledRecordings = self.scheduledRecordings_cache
try:
if os.stat(config.TV_RECORD_SCHEDULE)[stat.ST_MTIME] == mod_time:
_debug_('Return cached data', 2)
return scheduledRecordings
except OSError:
pass
f = open(config.TV_RECORD_SCHEDULE, 'r')
scheduledRecordings = unjellyFromXML(f)
f.close()
try:
file_ver = scheduledRecordings.TYPES_VERSION
except AttributeError:
_debug_('The cache does not have a version and must be recreated.')
if file_ver != TYPES_VERSION:
_debug_(('ScheduledRecordings version number %s is stale (new is %s), must ' +
'be reloaded') % (file_ver, TYPES_VERSION))
scheduledRecordings = None
else:
_debug_('Got ScheduledRecordings (version %s).' % file_ver)
if not scheduledRecordings:
_debug_('GET: making a new ScheduledRecordings')
scheduledRecordings = ScheduledRecordings()
self.saveScheduledRecordings(scheduledRecordings)
_debug_('ScheduledRecordings has %s items.' % \
len(scheduledRecordings.programList))
try:
mod_time = os.stat(config.TV_RECORD_SCHEDULE)[stat.ST_MTIME]
self.scheduledRecordings_cache = mod_time, scheduledRecordings
except OSError:
pass
return scheduledRecordings
#
# function to save the schedule to disk
#
def saveScheduledRecordings(self, scheduledRecordings=None):
if not scheduledRecordings:
_debug_('SAVE: making a new ScheduledRecordings')
scheduledRecordings = ScheduledRecordings()
_debug_('SAVE: saving cached file (%s)' % config.TV_RECORD_SCHEDULE)
_debug_("SAVE: ScheduledRecordings has %s items." % \
len(scheduledRecordings.programList))
try:
f = open(config.TV_RECORD_SCHEDULE, 'w')
except IOError:
os.unlink(config.TV_RECORD_SCHEDULE)
f = open(config.TV_RECORD_SCHEDULE, 'w')
jellyToXML(scheduledRecordings, f)
f.close()
try:
mod_time = os.stat(config.TV_RECORD_SCHEDULE)[stat.ST_MTIME]
self.scheduledRecordings_cache = mod_time, scheduledRecordings
except OSError:
pass
return TRUE
def scheduleRecording(self, prog=None):
global guide
if not prog:
return (FALSE, 'no prog')
if prog.stop < time.time():
return (FALSE, 'cannot record it if it is over')
self.updateGuide()
for chan in guide.chan_list:
if prog.channel_id == chan.id:
_debug_('scheduleRecording: prog.channel_id="%s" chan.id="%s" chan.tunerid="%s"' %
(prog.channel_id, chan.id, chan.tunerid))
prog.tunerid = chan.tunerid
scheduledRecordings = self.getScheduledRecordings()
scheduledRecordings.addProgram(prog, tv_util.getKey(prog))
self.saveScheduledRecordings(scheduledRecordings)
# check, maybe we need to start right now
self.checkToRecord()
return (TRUE, 'recording scheduled')
def removeScheduledRecording(self, prog=None):
if not prog:
return (FALSE, 'no prog')
# get our version of 'prog'
# It's a bad hack, but we can use isRecording than
sr = self.getScheduledRecordings()
progs = sr.getProgramList()
for saved_prog in progs.values():
if String(saved_prog) == String(prog):
prog = saved_prog
break
try:
recording = prog.isRecording
except Exception, e:
print e
recording = FALSE
scheduledRecordings = self.getScheduledRecordings()
scheduledRecordings.removeProgram(prog, tv_util.getKey(prog))
self.saveScheduledRecordings(scheduledRecordings)
now = time.time()
# if prog.start <= now and prog.stop >= now and recording:
if recording:
#print 'stopping current recording'
rec_plugin = plugin.getbyname('RECORD')
if rec_plugin:
rec_plugin.Stop(self.findCard(prog))
return (TRUE, 'recording removed')
def isProgScheduled(self, prog, schedule=None):
if schedule == {}:
return (FALSE, 'prog not scheduled')
if not schedule:
schedule = self.getScheduledRecordings().getProgramList()
for me in schedule.values():
if me.start == prog.start and me.channel_id == prog.channel_id:
return (TRUE, 'prog is scheduled')
return (FALSE, 'prog not scheduled')
def findProg(self, chan=None, start=None):
global guide
_debug_('findProg: %s, %s' % (chan, start))
if not chan or not start:
return (FALSE, 'no chan or no start')
self.updateGuide()
for ch in guide.chan_list:
if chan == ch.id:
_debug_('CHANNEL MATCH: %s' % ch.id)
for prog in ch.programs:
if start == '%s' % prog.start:
_debug_('PROGRAM MATCH 1: %s' % prog.title)
return (TRUE, prog.utf2str())
return (FALSE, 'prog not found')
def findMatches(self, find=None, movies_only=None):
global guide
_debug_('findMatches: %s' % find)
matches = []
max_results = 500
if not find and not movies_only:
_debug_('nothing to find')
return (FALSE, 'no search string')
self.updateGuide()
pattern = '.*' + find + '\ *'
regex = re.compile(pattern, re.IGNORECASE)
now = time.time()
for ch in guide.chan_list:
for prog in ch.programs:
if prog.stop < now:
continue
if not find or regex.match(prog.title) or regex.match(prog.desc) \
or regex.match(prog.sub_title):
if movies_only:
# We can do better here than just look for the MPAA
# rating. Suggestions are welcome.
if 'MPAA' in prog.utf2str().getattr('ratings').keys():
matches.append(prog.utf2str())
_debug_('PROGRAM MATCH 2: %s' % prog)
else:
# We should never get here if not find and not
# movies_only.
matches.append(prog.utf2str())
_debug_('PROGRAM MATCH 3: %s' % prog)
if len(matches) >= max_results:
break
_debug_('Found %d matches.' % len(matches))
if matches:
return (TRUE, matches)
else:
return (FALSE, 'no matches')
def updateGuide(self):
global guide
# XXX TODO: only do this if the guide has changed?
guide = tv.epg_xmltv.get_guide()
def findCard(self,prog):
print "FINDCARD: ",prog
for i in range(len(self.cardrecording)):
print "COMPARING WITH", self.cardrecording[i]
if prog.title+"%s"%prog.channel_id==self.cardrecording[i]:
print "RETURNING 1"
return i
print "WHOOPS, CAN'T FIND IT"
def checkToRecord(self):
rec_cmd = None
rec_prog = None
rec_progs = []
cleaned = None
delay_recording = FALSE
sr = self.getScheduledRecordings()
progs = sr.getProgramList()
currently_recording = None
currently_recordings = []
for prog in progs.values():
try:
recording = prog.isRecording
except:
recording = FALSE
if recording:
currently_recordings.append(prog)
currently_recording = prog
print "currently_recordings=",currently_recordings
if len(currently_recordings)<len(config.VIDEO_GROUPS):
#FIX THIS yes this is a hack, assuming capture devices can all capture the same source
#so we are recording less channels than the number of capture devices, we have no problem
currently_recording=None
print "no conflict, cleareing currently_recording"
now = time.time()
for prog in progs.values():
_debug_('checkToRecord: progloop=%s' % prog, 2)
try:
recording = prog.isRecording
except:
recording = FALSE
if (prog.start - config.TV_RECORD_PADDING_PRE) <= now \
and (prog.stop + config.TV_RECORD_PADDING_POST) >= now \
and not recording:
# just add to the 'we want to record this' list
# then end the loop, and figure out which has priority,
# remember to take into account the full length of the shows
# and how much they overlap, or chop one short
duration = int((prog.stop + config.TV_RECORD_PADDING_POST) - now - 10)
if duration < 10:
return
if currently_recording:
#hmm what now we have a conflict
# is a show on one of the channels ending? If so pick that on
print "trying to resolve conflict. Is there a show that should end at", prog.start
for currently_recording in currently_recordings:
print "testing:",currently_recording.title,currently_recording.stop,currently_recording.start
if currently_recording.stop - 10 <= prog.start:
# The only reason we are still recording is because of
# the post-record padding.
#kill this one
print "found it"
break
#Ok at the end of this loop we simply take the last one examined
# Hey, something is already recording!
if prog.start - 10 <= now:
# our new recording should start no later than now!
# check if the new prog is a favorite and the current running is
# not. If so, the user manually added something, we guess it
# has a higher priority.
if self.isProgAFavorite(prog)[0] and \
not self.isProgAFavorite(currently_recording)[0] and \
prog.stop + config.TV_RECORD_PADDING_POST > now:
_debug_('ignore %s' % prog)
continue
sr.removeProgram(currently_recording,
tv_util.getKey(currently_recording))
plugin.getbyname('RECORD').Stop(self.findCard(currently_recording))
time.sleep(5)
_debug_('CALLED RECORD STOP 1: %s' % currently_recording)
else:
# at this moment we must be in the pre-record padding
if currently_recording.stop - 10 <= now:
# The only reason we are still recording is because of
# the post-record padding.
# Therefore we have overlapping paddings but not
# real stop / start times.
overlap = (currently_recording.stop + \
config.TV_RECORD_PADDING_POST) - \
(prog.start - config.TV_RECORD_PADDING_PRE)
if overlap <= ((config.TV_RECORD_PADDING_PRE +
config.TV_RECORD_PADDING_POST)/4):
sr.removeProgram(currently_recording,
tv_util.getKey(currently_recording))
plugin.getbyname('RECORD').Stop(self.findCard(currently_recording))
time.sleep(5)
_debug_('CALLED RECORD STOP 2: %s' % currently_recording)
else:
delay_recording = TRUE
else:
delay_recording = TRUE
if delay_recording:
_debug_('delaying: %s' % prog)
else:
_debug_('going to record: %s' % prog)
prog.isRecording = TRUE
prog.rec_duration = duration
prog.filename = tv_util.getProgFilename(prog)
rec_progs.append(prog)
for prog in progs.values():
# If the program is over remove the entry.
if ( prog.stop + config.TV_RECORD_PADDING_POST) < now:
_debug_('found a program to clean: %s' % prog)
cleaned = TRUE
del progs[tv_util.getKey(prog)]
if rec_progs or cleaned:
sr.setProgramList(progs)
self.saveScheduledRecordings(sr)
if rec_progs:
for rec_prog in rec_progs:
_debug_('start recording: %s' % rec_prog)
self.record_app = plugin.getbyname('RECORD')
if not self.record_app:
print_plugin_warning()
_debug_('ERROR: Recording %s failed.' % rec_prog.title, 0)
self.removeScheduledRecording(rec_prog)
return
self.vg = self.fc.getVideoGroup(rec_prog.channel_id, FALSE)
cardID,vdev=self.record_app.Record(rec_prog)
#yes there is a small chance that you get a problem. by not creating the lockfile before starting the record
print "VDEV=",vdev
suffix=vdev.split('/')[-1]
print "SUFFIX=",suffix
rec_prog.tv_lock_file = config.FREEVO_CACHEDIR + '/record.'+suffix
self.cardrecording[cardID]=rec_prog.title+"%s"%rec_prog.channel_id
def addFavorite(self, name, prog, exactchan=FALSE, exactdow=FALSE, exacttod=FALSE):
if not name:
return (FALSE, 'no name')
(status, favs) = self.getFavorites()
priority = len(favs) + 1
fav = tv.record_types.Favorite(name, prog, exactchan, exactdow, exacttod, priority)
scheduledRecordings = self.getScheduledRecordings()
scheduledRecordings.addFavorite(fav)
self.saveScheduledRecordings(scheduledRecordings)
self.addFavoriteToSchedule(fav)
return (TRUE, 'favorite added')
def addEditedFavorite(self, name, title, chan, dow, mod, priority):
fav = tv.record_types.Favorite()
fav.name = name
fav.title = title
fav.channel = chan
fav.dow = dow
fav.mod = mod
fav.priority = priority
scheduledRecordings = self.getScheduledRecordings()
scheduledRecordings.addFavorite(fav)
self.saveScheduledRecordings(scheduledRecordings)
self.addFavoriteToSchedule(fav)
return (TRUE, 'favorite added')
def removeFavorite(self, name=None):
if not name:
return (FALSE, 'no name')
(status, fav) = self.getFavorite(name)
self.removeFavoriteFromSchedule(fav)
scheduledRecordings = self.getScheduledRecordings()
scheduledRecordings.removeFavorite(name)
self.saveScheduledRecordings(scheduledRecordings)
return (TRUE, 'favorite removed')
def clearFavorites(self):
scheduledRecordings = self.getScheduledRecordings()
scheduledRecordings.clearFavorites()
self.saveScheduledRecordings(scheduledRecordings)
return (TRUE, 'favorites cleared')
def getFavorites(self):
return (TRUE, self.getScheduledRecordings().getFavorites())
def getFavorite(self, name):
(status, favs) = self.getFavorites()
if favs.has_key(name):
fav = favs[name]
return (TRUE, fav)
else:
return (FALSE, 'not a favorite')
def adjustPriority(self, favname, mod=0):
save = []
mod = int(mod)
(status, me) = self.getFavorite(favname)
oldprio = int(me.priority)
newprio = oldprio + mod
_debug_('ap: mod=%s' % mod)
sr = self.getScheduledRecordings()
favs = sr.getFavorites().values()
_debug_('adjusting prio of '+favname)
for fav in favs:
fav.priority = int(fav.priority)
if fav.name == me.name:
_debug_('MATCH')
fav.priority = newprio
_debug_('moved prio of %s: %s => %s' % (fav.name, oldprio, newprio))
continue
if mod < 0:
if fav.priority < newprio or fav.priority > oldprio:
_debug_('fp: %s, old: %s, new: %s' % (fav.priority, oldprio, newprio))
_debug_('skipping: %s' % fav.name)
continue
fav.priority = fav.priority + 1
_debug_('moved prio of %s: %s => %s' % (fav.name, fav.priority-1, fav.priority))
if mod > 0:
if fav.priority > newprio or fav.priority < oldprio:
_debug_('skipping: %s' % fav.name)
continue
fav.priority = fav.priority - 1
_debug_('moved prio of %s: %s => %s' % (fav.name, fav.priority+1, fav.priority))
sr.setFavoritesList(favs)
self.saveScheduledRecordings(sr)
return (TRUE, 'priorities adjusted')
def isProgAFavorite(self, prog, favs=None):
if not favs:
(status, favs) = self.getFavorites()
lt = time.localtime(prog.start)
dow = '%s' % lt[6]
# tod = '%s:%s' % (lt[3], lt[4])
# mins_in_day = 1440
min_of_day = '%s' % ((lt[3]*60)+lt[4])
for fav in favs.values():
if prog.title.encode('utf-8').lower().find(fav.title.encode('utf-8').lower()) >= 0:
if fav.channel == tv_util.get_chan_displayname(prog.channel_id) \
or fav.channel == 'ANY':
if Unicode(fav.dow) == Unicode(dow) or Unicode(fav.dow) == u'ANY':
if Unicode(fav.mod) == Unicode(min_of_day) or \
Unicode(fav.mod) == u'ANY':
return (TRUE, fav.name)
elif abs(int(fav.mod) - int(min_of_day)) <= 8:
return (TRUE, fav.name)
# if we get this far prog is not a favorite
return (FALSE, 'not a favorite')
def removeFavoriteFromSchedule(self, fav):
# TODO: make sure the program we remove is not
# covered by another favorite.
tmp = {}
tmp[fav.name] = fav
scheduledRecordings = self.getScheduledRecordings()
progs = scheduledRecordings.getProgramList()
for prog in progs.values():
(isFav, favorite) = self.isProgAFavorite(prog, tmp)
if isFav:
self.removeScheduledRecording(prog)
return (TRUE, 'favorite unscheduled')
def addFavoriteToSchedule(self, fav):
global guide
favs = {}
favs[fav.name] = fav
self.updateGuide()
for ch in guide.chan_list:
for prog in ch.programs:
(isFav, favorite) = self.isProgAFavorite(prog, favs)
if isFav:
prog.isFavorite = favorite
self.scheduleRecording(prog)
return (TRUE, 'favorite scheduled')
def updateFavoritesSchedule(self):
# TODO: do not re-add a prog to record if we have
# previously decided not to record it.
global guide
self.updateGuide()
# First get the timeframe of the guide.
last = 0
for ch in guide.chan_list:
for prog in ch.programs:
if prog.start > last: last = prog.start
scheduledRecordings = self.getScheduledRecordings()
(status, favs) = self.getFavorites()
if not len(favs):
return (FALSE, 'there are no favorites to update')
# Then remove all scheduled favorites in that timeframe to
# make up for schedule changes.
progs = scheduledRecordings.getProgramList()
for prog in progs.values():
# try:
# favorite = prog.isFavorite
# except:
# favorite = FALSE
# if prog.start <= last and favorite:
(isFav, favorite) = self.isProgAFavorite(prog, favs)
if prog.start <= last and isFav:
# do not yet remove programs currently being recorded:
isRec = hasattr(prog, "isRecording") and prog.isRecording
if not isRec:
self.removeScheduledRecording(prog)
for ch in guide.chan_list:
for prog in ch.programs:
(isFav, favorite) = self.isProgAFavorite(prog, favs)
isRec = hasattr(prog, "isRecording") and prog.isRecording
if isFav and not isRec:
prog.isFavorite = favorite
self.scheduleRecording(prog)
return (TRUE, 'favorites schedule updated')
#################################################################
# Start XML-RPC published methods. #
#################################################################
def xmlrpc_isPlayerRunning(self):
(status, message) = (FALSE, 'RecordServer::isPlayerRunning: cannot acquire lock')
try:
self.lock.acquire()
status = self.isPlayerRunning()
message = status and 'player is running' or 'player is not running'
finally:
self.lock.release()
return (status, message)
def xmlrpc_isRecording(self):
(status, message) = (FALSE, 'RecordServer::isRecording: cannot acquire lock')
try:
status = self.isRecording()
message = status and 'is recording' or 'is not recording'
finally:
self.lock.release()
return (status, message)
def xmlrpc_findNextProgram(self):
(status, message) = (FALSE, 'RecordServer::findNextProgram: cannot acquire lock')
try:
self.lock.acquire()
response = self.findNextProgram()
status = response != None
return (status, jellyToXML(response))
finally:
self.lock.release()
return (status, message)
def xmlrpc_getScheduledRecordings(self):
(status, message) = (FALSE, 'RecordServer::getScheduledRecordings: cannot acquire lock')
try:
self.lock.acquire()
return (TRUE, jellyToXML(self.getScheduledRecordings()))
finally:
self.lock.release()
return (status, message)
def xmlrpc_saveScheduledRecordings(self, scheduledRecordings=None):
(status, message) = (FALSE, 'RecordServer::saveScheduledRecordings: cannot acquire lock')
try:
self.lock.acquire()
status = self.saveScheduledRecordings(scheduledRecordings)
message = status and 'saveScheduledRecordings::success' or 'saveScheduledRecordings::failure'
finally:
self.lock.release()
return (status, message)
def xmlrpc_scheduleRecording(self, prog=None):
if not prog:
return (FALSE, 'RecordServer::scheduleRecording: no prog')
(status, message) = (FALSE, 'RecordServer::scheduleRecording: cannot acquire lock')
try:
self.lock.acquire()
prog = unjellyFromXML(prog)
(status, response) = self.scheduleRecording(prog)
message = 'RecordServer::scheduleRecording: %s' % response
finally:
self.lock.release()
return (status, message)
def xmlrpc_removeScheduledRecording(self, prog=None):
if not prog:
return (FALSE, 'RecordServer::removeScheduledRecording: no prog')
(status, message) = (FALSE, 'RecordServer::removeScheduledRecording: cannot acquire lock')
try:
self.lock.acquire()
prog = unjellyFromXML(prog)
(status, response) = self.removeScheduledRecording(prog)
message = 'RecordServer::removeScheduledRecording: %s' % response
finally:
self.lock.release()
return (status, message)
def xmlrpc_isProgScheduled(self, prog=None, schedule=None):
if not prog:
return (FALSE, 'removeScheduledRecording::failure: no prog')
(status, message) = (FALSE, 'RecordServer::removeScheduledRecording: cannot acquire lock')
try:
self.lock.acquire()
prog = unjellyFromXML(prog)
if schedule:
schedule = unjellyFromXML(schedule)
(status, response) = self.isProgScheduled(prog, schedule)
message = 'RecordServer::isProgScheduled: %s' % response
finally:
self.lock.release()
return (status, message)
def xmlrpc_findProg(self, chan, start):
(status, message) = (FALSE, 'RecordServer::findProg: cannot acquire lock')
try:
self.lock.acquire()
(status, response) = self.findProg(chan, start)
message = status and jellyToXML(response) or ('RecordServer::findProg: %s' % response)
finally:
self.lock.release()
return (status, message)
def xmlrpc_findMatches(self, find, movies_only):
(status, message) = (FALSE, 'RecordServer::findMatches: cannot acquire lock')
try:
self.lock.acquire()
(status, response) = self.findMatches(find, movies_only)
message = status and jellyToXML(response) or ('RecordServer::findMatches: %s' % response)
finally:
self.lock.release()
return (status, message)
def xmlrpc_echotest(self, blah):
(status, message) = (FALSE, 'RecordServer::echotest: cannot acquire lock')
try:
self.lock.acquire()
(status, message) = (TRUE, 'RecordServer::echotest: %s' % blah)
finally:
self.lock.release()
return (status, message)
def xmlrpc_addFavorite(self, name, prog, exactchan=FALSE, exactdow=FALSE, exacttod=FALSE):
(status, message) = (FALSE, 'RecordServer::addFavorite: cannot acquire lock')
try:
self.lock.acquire()
prog = unjellyFromXML(prog)
(status, response) = self.addFavorite(name, prog, exactchan, exactdow, exacttod)
message = 'RecordServer::addFavorite: %s' % response
finally:
self.lock.release()
return (status, message)
def xmlrpc_addEditedFavorite(self, name, title, chan, dow, mod, priority):
(status, message) = (FALSE, 'RecordServer::addEditedFavorite: cannot acquire lock')
try:
self.lock.acquire()
(status, response) = self.addEditedFavorite(unjellyFromXML(name), \
unjellyFromXML(title), chan, dow, mod, priority)
message = 'RecordServer::addEditedFavorite: %s' % response
finally:
self.lock.release()
return (status, message)
def xmlrpc_removeFavorite(self, name=None):
(status, message) = (FALSE, 'RecordServer::removeFavorite: cannot acquire lock')
try:
self.lock.acquire()
(status, response) = self.removeFavorite(name)
message = 'RecordServer::removeFavorite: %s' % response
finally:
self.lock.release()
return (status, message)
def xmlrpc_clearFavorites(self):
(status, message) = (FALSE, 'RecordServer::clearFavorites: cannot acquire lock')
try:
self.lock.acquire()
(status, response) = self.clearFavorites()
message = 'RecordServer::clearFavorites: %s' % response
finally:
self.lock.release()
return (status, message)
def xmlrpc_getFavorites(self):
(status, message) = (FALSE, 'RecordServer::getFavorites: cannot acquire lock')
try:
self.lock.acquire()
(status, message) = (TRUE, jellyToXML(self.getScheduledRecordings().getFavorites()))
finally:
self.lock.release()
return (status, message)
def xmlrpc_getFavorite(self, name):
(status, message) = (FALSE, 'RecordServer::getFavorite: cannot acquire lock')
try:
self.lock.acquire()
(status, response) = self.getFavorite(name)
message = status and jellyToXML(response) or 'RecordServer::getFavorite: %s' % response
finally:
self.lock.release()
return (status, message)
def xmlrpc_adjustPriority(self, favname, mod=0):
(status, message) = (FALSE, 'RecordServer::adjustPriority: cannot acquire lock')
try:
self.lock.acquire()
(status, response) = self.adjustPriority(favname, mod)
message = 'RecordServer::adjustPriority: %s' % response
finally:
self.lock.release()
return (status, message)
def xmlrpc_isProgAFavorite(self, prog, favs=None):
(status, message) = (FALSE, 'RecordServer::adjustPriority: cannot acquire lock')
try:
self.lock.acquire()
prog = unjellyFromXML(prog)
if favs:
favs = unjellyFromXML(favs)
(status, response) = self.isProgAFavorite(prog, favs)
message = 'RecordServer::adjustPriority: %s' % response
finally:
self.lock.release()
return (status, message)
def xmlrpc_removeFavoriteFromSchedule(self, fav):
(status, message) = (FALSE, 'RecordServer::removeFavoriteFromSchedule: cannot acquire lock')
try:
self.lock.acquire()
(status, response) = self.removeFavoriteFromSchedule(fav)
message = 'RecordServer::removeFavoriteFromSchedule: %s' % response
finally:
self.lock.release()
return (status, message)
def xmlrpc_addFavoriteToSchedule(self, fav):
(status, message) = (FALSE, 'RecordServer::addFavoriteToSchedule: cannot acquire lock')
try:
self.lock.acquire()
(status, response) = self.addFavoriteToSchedule(fav)
message = 'RecordServer::addFavoriteToSchedule: %s' % response
finally:
self.lock.release()
return (status, message)
def xmlrpc_updateFavoritesSchedule(self):
(status, message) = (FALSE, 'updateFavoritesSchedule: cannot acquire lock')
try:
self.lock.acquire()
(status, response) = self.updateFavoritesSchedule()
message = 'RecordServer::updateFavoritesSchedule: %s' % response
finally:
self.lock.release()
return (status, message)
#################################################################
# End XML-RPC published methods. #
#################################################################
def create_fxd(self, rec_prog):
from util.fxdimdb import FxdImdb, makeVideo
fxd = FxdImdb()
(filebase, fileext) = os.path.splitext(rec_prog.filename)
fxd.setFxdFile(filebase, overwrite=TRUE)
video = makeVideo('file', 'f1', os.path.basename(rec_prog.filename))
fxd.setVideo(video)
fxd.info['tagline'] = fxd.str2XML(rec_prog.sub_title)
fxd.info['plot'] = fxd.str2XML(rec_prog.desc)
fxd.info['runtime'] = None
fxd.info['recording_timestamp'] = str(time.time())
fxd.info['year'] = time.strftime('%m-%d ' + config.TV_TIMEFORMAT,
time.localtime(rec_prog.start))
fxd.title = rec_prog.title
fxd.writeFxd()
def startMinuteCheck(self):
next_minute = (int(time.time()/60) * 60 + 60) - int(time.time())
_debug_('top of the minute in %s seconds' % next_minute)
reactor.callLater(next_minute, self.minuteCheck)
def minuteCheck(self):
next_minute = (int(time.time()/60) * 60 + 60) - int(time.time())
if next_minute != 60:
# Compensate for timer drift
if DEBUG:
log.debug('top of the minute in %s seconds' % next_minute)
reactor.callLater(next_minute, self.minuteCheck)
else:
reactor.callLater(60, self.minuteCheck)
self.checkToRecord()
def eventNotice(self):
#print 'RECORDSERVER GOT EVENT NOTICE'
# Use callLater so that handleEvents will get called the next time
# through the main loop.
reactor.callLater(0, self.handleEvents)
def handleEvents(self):
#print 'RECORDSERVER HANDLING EVENT'
event = rc_object.get_event()
if event:
if event == OS_EVENT_POPEN2:
print 'popen %s' % event.arg[1]
event.arg[0].child = util.popen3.Popen3(event.arg[1])
elif event == OS_EVENT_WAITPID:
pid = event.arg[0]
print 'waiting on pid %s' % pid
for i in range(20):
try:
wpid = os.waitpid(pid, os.WNOHANG)[0]
except OSError:
# forget it
continue
if wpid == pid:
break
time.sleep(0.1)
elif event == OS_EVENT_KILL:
pid = event.arg[0]
sig = event.arg[1]
print 'killing pid %s with sig %s' % (pid, sig)
try:
os.kill(pid, sig)
except OSError:
pass
for i in range(20):
try:
wpid = os.waitpid(pid, os.WNOHANG)[0]
except OSError:
# forget it
continue
if wpid == pid:
break
time.sleep(0.1)
else:
print 'force killing with signal 9'
try:
os.kill(pid, 9)
except OSError:
pass
for i in range(20):
try:
wpid = os.waitpid(pid, os.WNOHANG)[0]
except OSError:
# forget it
continue
if wpid == pid:
break
time.sleep(0.1)
print 'recorderver: After wait()'
elif event == RECORD_START:
#print 'Handling event RECORD_START'
prog = event.arg
open(prog.tv_lock_file, 'w').close()
self.create_fxd(prog)
if config.VCR_PRE_REC:
util.popen3.Popen3(config.VCR_PRE_REC)
elif event == RECORD_STOP:
#print 'Handling event RECORD_STOP'
prog = event.arg
os.remove(prog.tv_lock_file)
try:
snapshot(prog.filename)
except:
# If automatic pickling fails, use on-demand caching when
# the file is accessed instead.
os.rename(vfs.getoverlay(prog.filename + '.raw.tmp'),
vfs.getoverlay(os.path.splitext(prog.filename)[0] + '.png'))
pass
if config.VCR_POST_REC:
util.popen3.Popen3(config.VCR_POST_REC)
else:
print 'not handling event %s' % str(event)
return
else:
print 'no event to get'
def main():
app = Application("RecordServer")
rs = RecordServer()
if (DEBUG == 0):
app.listenTCP(config.TV_RECORD_SERVER_PORT, server.Site(rs, logPath='/dev/null'))
else:
app.listenTCP(config.TV_RECORD_SERVER_PORT, server.Site(rs))
rs.startMinuteCheck()
rc_object.subscribe(rs.eventNotice)
app.run(save=0)
if __name__ == '__main__':
import traceback
import time
import glob
locks = glob.glob(config.FREEVO_CACHEDIR + '/record.*')
for f in locks:
print 'Removed old record lock \"%s\"' % f
os.remove(f)
while 1:
try:
start = time.time()
main()
break
except:
traceback.print_exc()
if start + 10 > time.time():
print 'server problem, sleeping 1 min'
time.sleep(60)
-------------------------------------------------------------------------
Take Surveys. Earn Cash. Influence the Future of IT
Join SourceForge.net's Techsay panel and you'll get the chance to share your
opinions on IT & business topics through brief surveys - and earn cash
http://www.techsay.com/default.php?page=join.php&p=sourceforge&CID=DEVDEV
_______________________________________________
Freevo-users mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/freevo-users