DescentBB

Code: Select all

import subprocess
import sys
import logging
import os
import re
import shutil
import threading

# This is a module for YAWDVR
# These modules should contain number of specific elements, as seen in
# this file.
# Make sure that this file follows proper python syntax.
# This module runs on each slave with parameters passed by the server.

######
# The action may be described by an ID string.
# This is the ID for the action that will be seen in the web interface.
# The default value is the filename.
# This matters for time-dependent actions. Actions with the same
# ID and parameter will always be conflicting.
# "parameter" is an interger passed to functions in the module
# that repesent the different ways that this module can be used.
# The meaning of the parameter needs to be defined in the init
# function.  An example: in this module, each parameter will be
# associated with a channel file and a DVB device number.
# The first parameter will always be 0.

ID = 'DVB Record'

# The type can either be 'time-dependent' or 'time-independent'
# Time dependant scripts will be started at a specific time and will
# carry a duration parameter, So they end at a specific time.
# They typically will not receive an input file to operate upon, but
# will produce an output file.

# Time independent scripts are run at a convenient time.  They typically
# receive an input file to operate upon, and will either modify the
# file or produce different output file(s).
# The webserver/backend will associate one time-dependant and multiple
# time-independant action, run in a chain.

# Default value = 'time-independent'

type = 'time-dependent'

# The above are two things that the server needs to know about this action.

# Things that don't need to pass on to the server

# Initialize some variables that the functions will use 
extprog = 'mplayer'

checkopt = '-list-options'

checkstr = 'dvb'

baseopt = ' -dumpstream'


# Init function for the action.  This function is run on the
# Slave machine and needs to accomplish a few main things:
#
# First, it needs to do whatever is necessary to make the run
# function work.  For example: this module needs there to be
# a channels.conf file for mplayer to know how to find channels.
# The initialization function creates one of these tables per
# slave parameter
#
# Second, it needs give the server certain information
# One thing should be sources associated.
# Another thing should be a specific listings source.
# Also, the server needs to know the type and ID.
# exiting with -1 as a return means that it failed.

def init(parameter, interactive):
    '''Initiate mplayer dvb record parameters'''
    # Check to make sure that mplayer is on the machine, compiled with
    # DVB Support
    p = subprocess.Popen([extprog, checkopt], stdout=subprocess.PIPE)
    stdout = p.stdout.read()
    if stdout.find(checkstr) == -1:
        logging.info(extprog + ' command with dvb support not found') 
        return(1)

    # Run a dvb scan and output to ~/.mplayer/channels.conf.$parameter$
    # I'm making this run each time this function is run, since
    # one of the reasons for runnings this may be channel
    # problems.
    #TODO: This is totally linux-specific.  Make this work
    #TODO cross-platform.
    #TODO code to pull the table from the config file or
    # query the user for to location of the file, hinting
    # so they can get it right.
    #
    #TODO: remove this hard-code once above is done.
    #TODO: note that this needs to be set per parameter
    freqtable = '/usr/share/dvb/atsc/us-ATSC-center-frequencies-8VSB'
    
    conf = os.path.expanduser('~/.mplayer/channels.conf.') + str(parameter)
    
    #TODO: update this to handle multiple parameters.
    #TODO: The adapter/frontend/demux needs to be set
    #TODO: per parameter, not hard-coded.
    adapter = '0'
    frontend = '0'
    demux = '0'
    
    #TODO Update this so it isn't just hard-coded so it's cross-platform
    scancmd = 'scan'
    # Perform the scan and dump the conf file.
    logging.info('scanning channels using' + freqtable)
    print('scanning channels using' + freqtable)
    print('(This will take a few minutes.)')

    scan = subprocess.Popen(
                            [scancmd, '-a ' + adapter, '-f ' + frontend,
                             '-d ' + demux, freqtable, '>'],
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE)
    chanstr = scan.stdout.read()
    chaninfo = scan.stderr.read()

    # By convention, we are going to define the channels by
    # number.  This provides a consistent string that can
    # be used in both the listings and mplayer. To accomplish
    # this, the channel info in the conf file needs to be
    # re-mapped.

    if chanstr != '':
        chans = {} 
        # Parse the stderr output to create the channel list
        inflines = chaninfo.split('\n')
        for l in inflines:
            if 'Channel number' in l:
                # Find the index of the channel number and channel name
                numidx = l.split().index('number:') + 1
                nameidx = l.split().index('Name:') + 1
                # Grab the channel number
                chan = l.split() [numidx].strip('.')
                # Change the : in the channel name to a -
                chan = chan.replace(':','-')
                # Grab the channel name
                name = ' '.join(l.split() [nameidx:])
                chans [chan] = name.strip('\'')
        
        # Rewrite chanstr to use the channel numbers rather than names.
        # This relies on matching channel names.
        # Note that if multiple channels have the same name, they will
        # Be matched in order - 1st with 1st 2nd with 2nd, etc.
        conflines = chanstr.split('\n')
        confout = []
        # Iterate through the channel list generated above 
        for k, v in chans.iteritems():
            # Iterate through the items in the conf file string
            for l in conflines:
                # If the two match (for the first match)
                if v in l:
                    line = l.split(':')
                    # Change the conf's channel name to the channel num
                    line[0] = k
                    # Add it to a list of valid conf lines
                    confout.append(':'.join(line))
                    # Consume the old conf line
                    conflines.remove(l)
                    break

        confstr = '\n'.join(confout)

        # Write the channel conf file
        with open(conf, 'w') as chanconf:
            chanconf.write(confstr)
            logging.info('channels found and written to' +  conf)
            print('channels found and written to' +  conf) 
    else:
        logging.info('no channels returned by scan, using existing file')
        logging.info('scan return:' + chaninfo)
        print('no channels returned by scan, using existing file')
        print('scan return:' + chaninfo)

    # Preparing to return the known channel numbers to the server.
    chanlist = []
    try:
        with open(conf, 'r') as chanconf:
            for line in chanconf:
                chanlist.append(line.split(':')[0])
    except(IOError):
         logging.info('Conf file does not exist. Make sure that you have specified')
         logging.info('the correct device and that it is accessible to the user')
         print('Conf file does not exist. Make sure that you have specified')
         print('the correct device and that it is accessible to the user')


    #TODO:
    #The function also needs to return the appropriate listings
    #module.  The listings module will:
    #1. have an init function to also make sure it can run.
    #2. have a match function that will match names returned
    #   by this module to the appropriate listings.
    #3. have a grab function that will actually go out and get
    #   the listings.
    #This listings module will only run on the server.
    listings = 'listings.xmltv'
    #TODO this shouldn't be hard-coded. The user should pick
    # from valid options.
    
    # Create a dictionary of items to return to the server
    serverret = {__name__ + '.' + str(parameter) + '.ID': ID,
                 __name__ + '.' + str(parameter) + '.type': type,
                 __name__ + '.' + str(parameter) + '.listings': listings,
                 __name__ + '.' + str(parameter) + '.sources': chanlist}
    
    return(serverret)


# The main run function follows.
# This is the function that will be invoked the majority of the time.
# The web server will pass details of invoking this to the slave
# The slave will in turn invoke this function to perform the recording.
# Note: it is up to the slave to invoke this when the asked by the
# server, and correctly calculate the necessary duration. 

# The function should return an indication of success or failure
# 0 indicates success, -1 indicates failure.

def run(source, duration, parameter, outfile):
    '''Dump a DVB stream using mplayer to a TS file'''
    #TODO cd to savedir so the file dumps in the correct place
    # Mplayer doesn't support the conf filename option, so copy the appropriate
    # parameter conf file to channels.conf
    conf = os.path.expanduser('~/.mplayer/channels.conf.') + str(parameter)
    dest = os.path.expanduser('~/.mplayer/channels.conf')
    shutil.copy(conf,dest)

    # Set up the command line for mplayer
    dvbopt = ' -dvbin card=' + str(parameter)
    outopt = ' -dumpfile ' + outfile
    channel = ' dvb://' + source
    runcmd = extprog + baseopt + dvbopt + outopt + channel
    logging.info('Starting Mplayer DVB record of channel ' + source)
    logging.debug(runcmd)
    print(runcmd)

    # Mplayer doesn't stop when using the -endpos option
    # Instead, use threading to spawn mplayer, and then kill
    # it after duration. duration should be specified in seconds.

    class Command(object):
        def __init__(self, cmd):
            self.cmd = cmd
            self.process = None

        def go(self, timeout):
            def target():
                self.process = subprocess.Popen(self.cmd.split())
                self.process.communicate()

            thread = threading.Thread(target=target)
            thread.start()

            thread.join(timeout)
            if thread.is_alive():
                self.process.terminate()
                thread.join()

    command = Command(runcmd)
    command.go(timeout=duration)

    logging.info('Finished Mplayer DVB record')
    
    # Check to see if the file exists and isn't empty
    if os.path.isfile(outfile) and os.stat(outfile).st_size != 0:
        logging.debug('record appears to have succeeded, file size ' +
                      str(os.stat(outfile).st_size) + 'bytes')
        return(0)
    else:
        logging.debug('Problem recording detected')
        return(-1)

Code: Select all

def run(cmd, timeout):
    process = subprocess.Popen(cmd.split())

    thread = threading.Thread(target=lambda: process.communicate())
    thread.start()

    thread.join(timeout)
    if thread.is_alive():
        process.terminate()
        thread.join()

Code: Select all

process = subprocess.Popen([cmd])
sleep duration
process.terminate()
sleep 3
try:
    process.kill()
except:
    logging.debug('process already dead')