#!/usr/bin/python2
import sys
import getopt
import socket
import os , re
import time
import string
import glob
from string import letters
from string import digits
from xml.dom.minidom import parseString
import errno, fcntl
import urllib2,urllib,json
#http://code.activestate.com/recipes/576891/
class ApplicationLock:
'''
Ensures application is running only once, by using a lock file.
Ensure call to lock works. Then call unlock at program exit.
You cannot read or write to the lock file, but for some reason you can
remove it. Once removed, it is still in a locked state somehow. Another
application attempting to lock against the file will fail, even though
the directory listing does not show the file. Mysterious, but we are glad
the lock integrity is upheld in such a case.
Instance variables:
lockfile -- Full path to lock file
lockfd -- File descriptor of lock file exclusively locked
'''
def __init__ (self, lockfile):
self.lockfile = lockfile
self.lockfd = None
def lock (self):
'''
Creates and holds on to the lock file with exclusive access.
Returns True if lock successful, False if it is not, and raises
an exception upon operating system errors encountered creating the
lock file.
'''
try:
#
# Create or else open and trucate lock file, in read-write mode.
#
# A crashed app might not delete the lock file, so the
# os.O_CREAT | os.O_EXCL combination that guarantees
# atomic create isn't useful here. That is, we don't want to
# fail locking just because the file exists.
#
# Could use os.O_EXLOCK, but that doesn't exist yet in my Python
#
self.lockfd = os.open (self.lockfile,
os.O_TRUNC | os.O_CREAT | os.O_RDWR)
# Acquire exclusive lock on the file, but don't block waiting for it
fcntl.flock (self.lockfd, fcntl.LOCK_EX | fcntl.LOCK_NB)
# Writing to file is pointless, nobody can see it
os.write (self.lockfd, "My Lockfile")
return True
except (OSError, IOError), e:
# Lock cannot be acquired is okay, everything else reraise exception
if e.errno in (errno.EACCES, errno.EAGAIN):
return False
else:
raise
def unlock (self):
try:
# FIRST unlink file, then close it. This way, we avoid file
# existence in an unlocked state
os.unlink (self.lockfile)
# Just in case, let's not leak file descriptors
os.close (self.lockfd)
except (OSError, IOError), e:
# Ignore error destroying lock file. See class doc about how
# lockfile can be erased and everything still works normally.
pass
#------- START OF TUNER CLASSES-----------
class v4l_tuners():
def __init__(self, device):
self.device = device
self.full_attribs = self.find_full_attribs()
self.full_udev_attribs = self.find_full_udev_attribs()
self.description,self.driver = self.find_description()
self.udev_props = self.parse_full_udev()
self.tuner_hash = self.find_tuner_hash()
self.udev_rule = self.create_udev_rule()
#self.staticdevice is set in create_udev_rule
def find_full_attribs(self):
cmd = 'v4l2-ctl -D -d' + self.device
return os.popen(cmd).readlines()
def find_full_udev_attribs(self):
cmd = 'udevadm info -a -p $(udevadm info -q path -n %s)' %self.device
return os.popen(cmd).readlines()
def find_description(self):
for line in self.full_attribs:
#print line
pos = string.find(line,"Driver name")
if pos >=0:
splitline= line.split(':')
Driver=splitline[1].strip()
pos = string.find(line,"Card type")
if pos >=0:
splitline= line.split(':')
Cardtype=splitline[1].strip()
pos = string.find(line,"Bus info")
if pos >=0:
splitline= line.split(':',1)
Businfo=splitline[1].strip()
return Cardtype,Driver
def parse_full_udev(self):
udev_props = []
#ATTRS{serial}=="00A2023E"\n',
#SUBSYSTEMS=="usb"\n',
#SUBSYSTEM=="video4linux"\n',
#KERNELS=="0000:08:08.0"\n',
#DRIVERS=="hdpvr"\n'
#DRIVERS=="ivtv"\n',
#ATTR{index}=="0"
match = ['SUBSYSTEM',
'SUBSYSTEMS',
'DRIVERS',
'KERNELS',
'ATTRS{serial}',
'ATTR{name}',
'ATTR{index}'
]
for item in match:
regex = re.compile('%s.*$' %item)
for line in self.full_udev_attribs:
m = regex.search(line.strip())
if m:
#print line
udev_props.append(line.strip())
break
#throw out kernels for usb subsystems.
if 'SUBSYSTEMS=="usb"' in udev_props:
#print "found usb"
new_udev_props=[]
for index, item in enumerate(udev_props):
#print item,index
if item.startswith("DRIVERS=="):
continue
elif item.startswith("KERNELS=="):
continue
else:
new_udev_props.append(item)
udev_props = new_udev_props
return udev_props
def is_hdpvr(self):
if self.description == "Hauppauge HD PVR":
return True
return False
def is_mpeg(self):
if self.driver in ["ivtv","saa7164[0]","saa7164"]:
return True
return False
def find_tuner_hash(self):
#tuner hash will be driven by card_type pci id and index
i=''
k=''
tuner_hash=''
card_type = self.get_card_type()
if card_type == "v4l_hdpvr":
for index, item in enumerate(self.udev_props):
if item.startswith("ATTRS{serial}=="):
hex_serial=item.split("==")[1].strip('''"''')
serial = int(hex_serial, 16)
tuner_hash="hdpvr_%s" %serial
else:
for index, item in enumerate(self.udev_props):
if item.startswith("KERNELS=="):
k=item.split("==")[1].strip('''"''')
k=k.replace(":", "_")
k=k.replace("0", "")
k=k.replace(".", "")
if item.startswith("ATTR{index}=="):
i=item.split("==")[1].strip('''"''')
tuner_hash="%s%s%s" %(card_type,k,i)
return tuner_hash
def escapeSpecialCharacters ( self, text, characters ):
for character in characters:
text = text.replace( character, '\\' + character )
return text
def create_udev_rule(self):
#DRIVERS=="ivtv", ATTR{name}=="ivtv? encoder MPG", KERNELS=="0000:08:09.0" SYMLINK+="myth/aivtv2"
line = ','.join(self.udev_props)
line += ' SYMLINK+="vstatic/%s"' %(self.get_tuner_hash())
self.staticdevice = "/dev/vstatic/%s" %(self.get_tuner_hash())
return self.escapeSpecialCharacters(line,'[]')
def card_mpeg_values(self):
values = {
'CardType' : 'MPEG' ,
'VideoDevice' : self.staticdevice,
'Defaultinput' : 'Television',
'HostName' : self.localhostname,
'dvb_wait_for_seqstart' :'1',
'signal_timeout' :'1000',
'channel_timeout' :'12000',
'diseqcid' :'NULL',
'dvb_eitscan' :'1'
}
return values
def card_hdpvr_values(self):
values = {
'CardType' : 'HDPVR' ,
'VideoDevice' : self.staticdevice,
'Defaultinput' : 'Television',
'HostName' : self.localhostname,
'dvb_wait_for_seqstart' :'1',
'signal_timeout' :'1000',
'channel_timeout' :'12000',
'diseqcid' :'NULL',
'dvb_eitscan' :'1'
}
return values
def do_insert(self,values):
try:
header = { 'User-Agent' : "autocard" }
url="http://127.0.0.1:6544/Capture/AddCaptureCard/"
data = urllib.urlencode(values)
req = urllib2.Request(url, data, header)
self.response = urllib2.urlopen(req)
except:
print " **Insert of %s failed" %self.staticdevice
def insert_myth(self,myth_tuner_list):
#check if tuner is already in the db
if self.staticdevice in myth_tuner_list:
print " *%s %s already in mythdb" %(self.get_card_type(),self.staticdevice)
else:
#determine values to use based on card type
print " Inserting %s" %self.staticdevice
if self.is_hdpvr() == True:
values = self.card_hdpvr_values()
self.do_insert(values)
elif self.is_mpeg() == True:
values = self.card_mpeg_values()
self.do_insert(values)
else:
print " Unknown V4l type, not adding to myth database"
return
def set_hostname(self,hostname):
self.localhostname = hostname
def set_tuner_index(self,index):
#only used by dvb, but here to be complete
self.tuner_index = index
def get_dev_node(self):
return self.device
def get_full_attribs(self):
return self.full_attribs
def get_full_udev_attribs(self):
return self.full_udev_attribs
def get_card_type(self):
if self.is_hdpvr() == True :
rc = "v4l_hdpvr"
elif self.is_mpeg() == True:
rc = "v4l_mpeg"
else:
rc = "v4l"
return rc
def get_description(self):
return self.description
def get_udev_probs(self):
return self.udev_props
def get_tuner_hash(self):
return self.tuner_hash
def get_udev_rule(self):
return self.udev_rule
def get_static_device(self):
return self.staticdevice
#-----
class hdhr_tuners():
def __init__(self, device,ip):
self.device = device
self.ip = ip
self.description = self.find_description()
self.staticdevice = device
def find_description(self):
command = '/usr/bin/hdhomerun_config %s get /sys/hwmodel' %self.device
results=os.popen(command,'r')
return results.readline().strip()
def insert_myth(self,hdhr_list):
if self.device in hdhr_list:
print " *hdhr %s already in mythtdb" %self.device
else:
print " Inserting HDHR %s" %self.device
self.do_insert()
pass
def do_insert(self):
try:
header = { 'User-Agent' : "autocard" }
url="http://127.0.0.1:6544/Capture/AddCaptureCard/"
values = self.card_hdhr_values()
data = urllib.urlencode(values)
req = urllib2.Request(url, data, header)
self.response = urllib2.urlopen(req)
except:
print " **Insert of %s failed" %self.device
def card_hdhr_values(self):
values = {
'CardType' : 'HDHOMERUN' ,
'VideoDevice' : self.device,
'Defaultinput' : 'Television',
'HostName' : self.localhostname,
'dvb_wait_for_seqstart' :'1',
'signal_timeout' :'1000',
'channel_timeout' :'3000',
'diseqcid' :'NULL',
'dvb_eitscan' :'1'
}
return values
def set_hostname(self,hostname):
self.localhostname = hostname
def set_tuner_index(self,index):
#only used by dvb, but here to be complete
self.tuner_index = index
def get_dev_node(self):
return self.device
def get_card_type(self):
return "hdhr"
def get_description(self):
desc = "%s - %s" %(self.description,self.ip)
return desc
def get_udev_rule(self):
return
def get_tuner_hash(self):
return self.device
def get_static_device(self):
return self.staticdevice
#-----
class dvb_tuners():
def __init__(self, device):
self.device = device
self.tuner_index = 1
self.dvb_number = self.find_dvb_number()
self.description = self.find_description()
self.full_udev_attribs = self.find_full_udev_attribs()
self.udev_props = self.parse_full_udev()
self.tuner_hash = self.find_tuner_hash()
self.udev_rule = self.create_udev_rule()
#self.staticdevice is set in create_udev_rule
def find_description(self):
command = '/usr/bin/dvb-fe-tool -g -a %s' %self.dvb_number
results=os.popen(command,'r')
line = results.readline().strip()
d = line.split('''(''')
return d[0]
def find_full_udev_attribs(self):
cmd = 'udevadm info -a -p $(udevadm info -q path -n %s)' %self.device
return os.popen(cmd).readlines()
def find_dvb_number(self):
#/dev/dvb/adapter2/frontend0
d=self.device.split("/")[3]
dvb_number=d.partition("adapter")[2]
return dvb_number
def parse_full_udev(self):
udev_props = ['KERNEL=="dvb?.frontend?"']
#ATTRS{serial}=="00A2023E"\n',
#SUBSYSTEMS=="usb"\n',
#SUBSYSTEM=="video4linux"\n',
#KERNELS=="0000:08:08.0"\n',
#DRIVERS=="hdpvr"\n'
#DRIVERS=="ivtv"\n',
#ATTR{index}=="0"
#KERNEL=="dvb1.frontend0"
match = ['SUBSYSTEM',
'SUBSYSTEMS',
'DRIVERS',
'KERNELS',
'ATTRS{serial}',
'ATTR{name}',
'ATTR{index}'
]
for item in match:
regex = re.compile('%s.*$' %item)
for line in self.full_udev_attribs:
m = regex.search(line.strip())
if m:
#print line
udev_props.append(line.strip())
break
#throw out kernels for usb subsystems.
if 'SUBSYSTEMS=="usb"' in udev_props:
#print "found usb"
new_udev_props=[]
for index, item in enumerate(udev_props):
#print item,index
if item.startswith("DRIVERS=="):
continue
elif item.startswith("KERNELS=="):
continue
else:
new_udev_props.append(item)
udev_props = new_udev_props
return udev_props
def find_tuner_hash(self):
#tuner hash will be driven by card_type pci id and index
i=''
k=''
tuner_hash=''
card_type = self.get_card_type()
for index, item in enumerate(self.udev_props):
if item.startswith("KERNELS=="):
k=item.split("==")[1].strip('''"''')
k=k.replace(":", "_")
k=k.replace("0", "")
k=k.replace(".", "")
if item.startswith("ATTR{index}=="):
i=item.split("==")[1].strip('''"''')
tuner_hash="%s%s%s" %(card_type,k,i)
return tuner_hash
def escapeSpecialCharacters ( self, text, characters ):
for character in characters:
text = text.replace( character, '\\' + character )
return text
def create_udev_rule(self):
line = ','.join(self.udev_props)
line += ' RUN+="/usr/MythVantage/bin/udev_link.sh %s $env{DEVNAME} "' %(self.get_tuner_hash())
self.staticdevice = "/dev/dvb/adapter_static_%s_%s/frontend0" %(self.get_tuner_hash(),self.tuner_index)
return self.escapeSpecialCharacters(line,'[]')
def insert_myth(self,myth_tuner_list):
if self.staticdevice in myth_tuner_list:
print " *dvb %s already in mythtdb" %self.staticdevice
else:
print " Inserting DVB Tuner %s" %self.staticdevice
self.do_insert()
pass
def do_insert(self):
try:
header = { 'User-Agent' : "autocard" }
url="http://127.0.0.1:6544/Capture/AddCaptureCard/"
values = self.card_dvb_values()
data = urllib.urlencode(values)
req = urllib2.Request(url, data, header)
self.response = urllib2.urlopen(req)
except:
print " **Insert of %s failed" %self.staticdevice
def card_dvb_values(self):
values = {
'CardType' : 'DVB' ,
'VideoDevice' : self.staticdevice,
'Defaultinput' : 'Television',
'HostName' : self.localhostname,
'dvb_wait_for_seqstart' :'1',
'signal_timeout' :'1000',
'channel_timeout' :'12000',
'diseqcid' :'NULL',
'dvb_on_demand' :'0',
'dvb_eitscan' :'1'
}
return values
def set_tuner_index(self,index):
self.tuner_index = index
self.tuner_hash = self.find_tuner_hash()
self.udev_rule = self.create_udev_rule()
def set_hostname(self,hostname):
self.localhostname = hostname
def get_dev_node(self):
return self.device
def get_card_type(self):
return "dvb"
def get_description(self):
return self.description
def get_full_udev_attribs(self):
return self.full_udev_attribs
def get_tuner_hash(self):
return self.tuner_hash
def get_udev_rule(self):
return self.udev_rule
def get_static_device(self):
return self.staticdevice
#--
class infinitv_tuner():
def __init__(self, tuner_number,ip):
self.tuner_number = tuner_number
self.ceton_defined_tuner = tuner_number + 1
self.ip = ip
self.serial_num = self.find_serial()
self.connection = self.find_connection()
self.description = self.find_description()
self.staticdevice = self.find_static()
def find_static(self):
static="%s-RTP.%s" %(self.ip,self.tuner_number)
return static
def find_connection(self):
uri='get_var.json?i=0&s=diag&v=Host_Connection'
try:
url="http://%s/%s" %(self.ip,uri)
req = urllib2.Request(url)
r = urllib2.urlopen(req).read()
response = r.split()[2].strip('''"''')
except:
response='unknown'
return response
def find_serial(self):
uri='get_var.json?i=0&s=diag&v=Host_Serial_Number'
try:
url="http://%s/%s" %(self.ip,uri)
req = urllib2.Request(url)
r = urllib2.urlopen(req).read()
response = r.split()[2].strip('''"''')
except:
response='unknown'
return response
def find_description(self):
desc="Ceton InfiniTV %s Tuner %s" %(self.connection,
self.ceton_defined_tuner)
return desc
def do_insert(self):
try:
header = { 'User-Agent' : "autocard" }
url="http://127.0.0.1:6544/Capture/AddCaptureCard/"
values = self.card_ceton_values()
data = urllib.urlencode(values)
req = urllib2.Request(url, data, header)
self.response = urllib2.urlopen(req)
except:
print " **Insert of %s failed" %self.staticdevice
def card_ceton_values(self):
values = {
'CardType' : 'CETON' ,
'VideoDevice' : self.staticdevice,
'Defaultinput' : 'Television',
'HostName' : self.localhostname,
'dvb_wait_for_seqstart' :'1',
'signal_timeout' :'1000',
'channel_timeout' :'3000',
'diseqcid' :'NULL',
'dvb_eitscan' :'1'
}
return values
def insert_myth(self,myth_tuner_list):
if self.staticdevice in myth_tuner_list:
print " *infinitv %s already in mythtdb" %self.staticdevice
else:
print " Inserting Ceton InfinitTV Tuner %s" %self.staticdevice
self.do_insert()
return
def write_proxy(self):
directory="/etc/ceton_proxy.d"
if not os.path.exists(directory):
os.makedirs(directory)
proxy_file = "%s/%s" %(directory,self.get_proxy_num())
try:
f = open(proxy_file,'w')
line="port=%s\n" %(self.get_proxy_num())
f.write(line)
line="ip=%s\n" %(self.ip)
f.write(line)
except:
print " *Problem creating proxy file %s" %proxy_file
return
def get_static_device(self):
return self.staticdevice
def get_tuner_hash(self):
return self.staticdevice
def set_proxy(self,proxy_num):
self.proxy_num = 7000 + proxy_num
return
def set_hostname(self,hostname):
self.localhostname = hostname
return
def set_tuner_index(self,index):
#only used by dvb, but here to be complete
self.tuner_index = index
return
def get_proxy_num(self):
return self.proxy_num
def get_udev_rule(self):
return
def get_card_type(self):
return "infinitv"
def get_description(self):
desc = "%s - %s" %(self.description,self.ip)
return desc
def get_serial_number(self):
return self.serial_num
#-- end infinitv
#------------------END TUNER CLASSES-----------------------
#------------------START OF TUNER GATHERING-----------------
def find_hdhr_tuner(hdhrdevice):
htuner_list=[]
command="/usr/bin/hdhomerun_config %s get /tuner%s/status"
#loop over 4 possible tuners
for i in range(4):
c=command %(hdhrdevice,i)
results=os.popen(c,'r')
lines=results.readlines()
try:
#if the first line starts with error, assume it's not a tuner and
#there are no more tuners for this device.
if lines[0].strip().startswith("ERROR"):
break
else:
t="%s-%s" %(hdhrdevice,i)
htuner_list.append(t)
except:
pass
return htuner_list
def gather_hdhr(tuner_list):
command="/usr/bin/hdhomerun_config --discover"
results=os.popen(command,'r')
lines=results.readlines()
try:
if lines[0].strip().split()[0] == "no":
print "HDHOMERUN not detected"
else:
for line in lines:
hdhrdevice=line.strip().split()[2]
hdhrip = line.strip().split()[5]
tuners = find_hdhr_tuner(hdhrdevice)
for t in tuners:
tuner_list.append(hdhr_tuners(t,hdhrip))
except:
print "Error finding HDHOMERUN"
return tuner_list
def gather_v4l(tuner_list):
try:
filelist = os.listdir('/dev/v4l/by-path/')
except OSError:
pass
#fakelist=['/dev/v4l/video3', 'ivtv', 'WinTV PVR 500 (unit #2)', '0000:04:09.0']
#cardlist.append(fakelist)
try:
p = re.compile('^/dev/video?\d$')
filelist = glob.glob("/dev/v4l/by-path/*video*")
for device in filelist:
Device=os.path.realpath(device)
if not p.search(Device):
continue
#print "real device node"
#print Device
tuner_list.append(v4l_tuners(Device))
except IOError:
print "no v4l cards found"
return tuner_list
def gather_dvb(tuner_list):
try:
filelist = os.listdir('/dev/dvb/')
except OSError:
pass
try:
for d in filelist:
if os.path.islink("/dev/dvb/"+d):
continue
Device=os.path.realpath("/dev/dvb/"+d+"/frontend0")
tuner_list.append(dvb_tuners(Device))
except:
print "no dvb cards found"
return tuner_list
def gather_ceton(tuner_list):
#find and configure ctn network interfaces
ceton_network_list = find_ceton_network_list()
#find all the cards on a network interface
for iface in ceton_network_list:
#command="cat /tmp/find_ceton.txt"
print "Scanning %s network for ceton infinitv" %iface
command="/usr/MythVantage/bin/discover_infinitv.py %s" %iface
results=os.popen(command,'r')
lines=results.readlines()
try:
print lines
if lines[0].strip().split()[0].lower() == "no":
print "Ceton not detected on %s" %iface
else:
for line in lines:
#Found InfiniTV. Location URL: http://192.168.200.1/description.xml
#cetondevice = line.strip().split()[0]
cetonip = line.strip().split("/")[2]
tuners = [0,1,2,3]
for t in tuners:
tuner_list.append(infinitv_tuner(t,cetonip))
except:
print "Error finding Ceton InfinitTV on %s" %iface
return tuner_list
#------------------END OF TUNER GATHERING-----------------
#----linhes specific for networking
def config_ctn_network(ctn_iface):
etcnetdir = "/etc/net/ifaces/%s" %ctn_iface
if not os.path.exists(etcnetdir):
print "Creating config for interface %s" %ctn_iface
os.mkdir(etcnetdir)
outline='''
TYPE=eth
DISABLED=no
BOOTPROTO=dhcp
ONBOOT=yes
CONFIG_WIRELESS=no
DHCP_ARGS="-C resolv.conf"
'''
optionfile="%s/options" %etcnetdir
f = open(optionfile, 'w')
f.write(outline)
f.close()
command="/etc/net/scripts/network.init start"
os.system(command)
else:
pass #config is present
def find_ceton_network_list():
import netifaces
netinterfaces = netifaces.interfaces()
ctnip=[]
for i in netinterfaces:
if i.startswith("ctn") or i.startswith("usb"):
#configure and start ctn network
try:
config_ctn_network(i)
#read ip
ctnip.append(netifaces.ifaddresses(i)
[netifaces.AF_INET][0]['addr'])
except:
print " * Error scanning network interface %s" %i
print " * Please check that the interface is ready and configured"
return ctnip
#--end of linhes specific
def gather_tuners():
tuner_list = []
tuner_list = gather_hdhr(tuner_list)
tuner_list = gather_v4l(tuner_list)
tuner_list = gather_dvb(tuner_list)
tuner_list = gather_ceton(tuner_list)
#set the number of times we have seen a specific tuner_hash
#This will be used by dvb when tuner_hashs conflict
tuner_count = {}
for i in tuner_list:
th = i.get_tuner_hash()
if th in tuner_count:
tuner_count[th] += 1
else:
tuner_count[th] = 1
i.set_tuner_index(tuner_count[th])
return tuner_list
def trigger_udev():
print "Reloading udev rules"
command = '/usr/bin/udevadm control --reload'
results=os.popen(command,'r')
print "Triggering udev events"
command = '/usr/bin/udevadm trigger'
results=os.popen(command,'r')
def write_udev_file(rule_list):
udevfile = '/etc/udev/rules.d/99-mv-persistent-video.rules'
try:
f = open(udevfile, 'w')
line = "#Do not edit this file, it is auto generated by autocard.py \n\n"
f.write(line)
for rule in rule_list:
if rule:
line = "%s \n" %(rule)
f.write(line)
f.close()
except:
print "Error creating %s" %udevfile
trigger_udev()
def write_udev_map(tuner_list):
udevfile = '/etc/udev/mv-persistent-video.description'
try:
f = open(udevfile, 'w')
line = "#Do not edit this file, it is auto generated by autocard.py \n"
f.write(line)
line = "#This file is used to generate the static tuner card web page\n"
f.write(line)
for i in tuner_list:
if i.get_card_type() == "hdhr":
pass
line="hdhr:%s:%s" %(i.get_description(),i.get_static_device())
f.write(line)
f.write("\n")
elif i.get_card_type() == "v4l_mpeg":
pass
line="V4L_mpeg:%s: %s " %(i.get_description(),i.get_static_device())
f.write(line)
f.write("\n")
elif i.get_card_type() == "v4l":
pass
line="V4L:%s:%s " %(i.get_description(),i.get_static_device())
f.write(line)
f.write("\n")
elif i.get_card_type() == "v4l_hdpvr":
pass
line="hdpvr:%s: %s " %(i.get_description(),i.get_static_device())
f.write(line)
f.write("\n")
elif i.get_card_type() == "dvb":
line="dvb:%s: %s " %(i.get_description(),i.get_static_device())
f.write(line)
f.write("\n")
elif i.get_card_type() == "infinitv":
line="infinitv:%s:%s:%s" %(i.get_description(),
i.get_static_device(),
i.get_proxy_num())
f.write(line)
f.write("\n")
else:
print i
line = i
f.write(line)
f.write("\n")
except:
print "Error creating %s" %udevfile
f.close()
def checkURL(url):
try:
connection = urllib2.urlopen(url,None,3)
code=connection.getcode()
connection.close()
if code == 200:
rc=0
#except urllib2.HTTPError, e:
except:
rc=1
return rc
def getURL(url):
dom = None
try:
connection = urllib2.urlopen(url,None,3)
data = connection.read()
connection.close()
dom = parseString(data)
#except urllib2.HTTPError, e:
except:
pass
return dom
def find_hdhr_in_use():
hdhr_list = []
url='http://127.0.0.1:6544/Capture/GetCaptureCardList?CardType=HDHOMERUN'
data = getURL(url)
if data:
xmlTags = data.getElementsByTagName('VideoDevice')
for i in xmlTags:
xmlTag=i.toxml()
xmlData=xmlTag.replace('','').replace('','')
hdhr_list.append(xmlData)
return hdhr_list
def find_in_use_card_list():
in_use_tuner_list=[]
url='http://127.0.0.1:6544/Capture/GetCaptureCardList?HostName=%s' %localhostname
data = getURL(url)
if data:
xmlTags = data.getElementsByTagName('VideoDevice')
for i in xmlTags:
xmlTag=i.toxml()
xmlData=xmlTag.replace('','').replace('','')
in_use_tuner_list.append(xmlData)
return in_use_tuner_list
def usuage():
help='''
Autocard.py is a program that will take the guess work out of setting up tuner/capture cards.
There are 4 options:
help : This help screen
print: Will find and printout any detected capture cards, including network based tuners like the hdhomerun_config
udev : This option creates a set of static device nodes for the local capture cards.
Rules are based on pci/usb path so moving the card into a different expansion slot will nullify the udev rule
HDPVR devices use the serial number as the primary key for the udev rule_list
insertdb : This option will insert any detected cards into the MythTV database using the static device generated by udev.
This option will also generate udev rules. Tuners that are already defined will not be readded.
write_proxy: This will write out the config used by the service ceton_proxy
all : The same as using print udev insertdb write_proxy
EX:
autocard.py print
autocard.py insertdb
'''
print help
def main(argv):
listcards = False
udev = False
insertdb = False
write_proxy = False
if argv==[] or "help" in argv:
usuage()
sys.exit(0)
if "print" in argv:
listcards = True
if "udev" in argv:
udev = True
write_proxy = True
if "insertdb" in argv:
insertdb = True
udev = True
write_proxy = True
if "write_proxy" in argv:
write_proxy = True
if "all" in argv:
udev = True
insertdb = True
listcards = True
write_proxy = True
tuner_list = gather_tuners()
rule_list = []
#setting the proxy port for ceton webpage
ceton_proxy = 1
for i in tuner_list:
if i.get_card_type() == "infinitv":
i.set_proxy(ceton_proxy)
ceton_proxy = ceton_proxy + 1
#setting the hostname for each tuner
i.set_hostname(localhostname)
rule_list.append(i.get_udev_rule())
if listcards == True:
print i.get_card_type()
print "----------------"
print "\t" , i.get_description()
print "\t" , i.get_static_device()
print("Writing out tuner map")
write_udev_map(tuner_list)
restart_proxy=False
if write_proxy == True:
for i in tuner_list:
if i.get_card_type() == "infinitv":
i.write_proxy()
restart_proxy=True
if restart_proxy == True:
command="add_service.sh cetonproxy"
os.system(command)
print" Restarting ceton proxy"
command="sv restart cetonproxy"
os.system(command)
if udev == True:
print("Writing out udev rules")
write_udev_file(rule_list)
if insertdb == True:
be_ready = False
i = 0
while i < 10 or be_ready :
if checkURL('http://127.0.0.1:6544') == 0:
be_ready = True
break
i = i + 1
print "Waiting for MythTV backend connection: %s/10" %i
time.sleep(5)
if be_ready == True :
#find all HDHR
in_use_hdhr_list = find_hdhr_in_use()
#find other cards local
in_use_local_card_list = find_in_use_card_list()
print "Adding cards to mythtv database"
for i in tuner_list:
if i.get_card_type() == "hdhr":
i.insert_myth(in_use_hdhr_list)
else:
i.insert_myth(in_use_local_card_list)
if __name__ == "__main__":
localhostname = socket.gethostname()
applock = ApplicationLock ('/var/run/autocard.lock')
if (applock.lock ()):
#print ("Obtained lock")
main(sys.argv[1:])
#print ("Unlocking")
applock.unlock ()
else:
print ("Unable to obtain lock, exiting")