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

Reply via email to