350 lines
11 KiB
Python
Executable File
350 lines
11 KiB
Python
Executable File
#! /usr/bin/python
|
|
|
|
# By Taybin Rutkin
|
|
#
|
|
# TODO
|
|
# look along $PATH to find binary.
|
|
# Use ardour binary to get version info
|
|
# hide file information from reporters
|
|
|
|
# standard
|
|
import os
|
|
import Queue
|
|
import re
|
|
import shutil
|
|
import string
|
|
import sys
|
|
import tempfile
|
|
import threading
|
|
import warnings
|
|
|
|
# probably installed
|
|
import pygtk
|
|
pygtk.require("2.0")
|
|
import gtk, gnome.ui
|
|
|
|
# we provide ClientForm and ClientCookie in $prefix/share/ardour/
|
|
sys.path.append('/usr/local/share/ardour/')
|
|
sys.path.append('/opt/local/share/ardour/')
|
|
sys.path.append('/opt/share/ardour/')
|
|
sys.path.append('/usr/share/ardour/')
|
|
|
|
# probably not installed
|
|
import ClientForm
|
|
import ClientCookie
|
|
|
|
warnings.filterwarnings('ignore', message="tempnam is a potential security risk to your program")
|
|
g_name = os.tempnam('/tmp', 'bugrp')
|
|
os.mkdir(g_name)
|
|
|
|
class NoBlock(threading.Thread):
|
|
def __init__(self, data, queue):
|
|
threading.Thread.__init__(self)
|
|
self.data = data
|
|
self.queue = queue
|
|
|
|
def zip(self):
|
|
self.queue.put('zipping')
|
|
os.system('tar cvfz ' + g_name + '.tar.gz ' + g_name + ' > /dev/null')
|
|
|
|
def login(self):
|
|
self.queue.put('logging in')
|
|
response = ClientCookie.urlopen('http://ardour.org/mantis/login.php?username=bug_tool&password=bug_tool')
|
|
print response
|
|
response.close()
|
|
|
|
def get_form(self):
|
|
self.queue.put('forming data')
|
|
response = ClientCookie.urlopen('http://ardour.org/mantis/bug_report_page.php')
|
|
print response
|
|
forms = ClientForm.ParseResponse(response)
|
|
self.form = forms[2]
|
|
|
|
def upload(self):
|
|
self.queue.put('uploading')
|
|
self.form.add_file(open(g_name+'.tar.gz'), 'application/x-gzip', 'system-info.tar.gz')
|
|
self.form['description'] = self.data['long']
|
|
self.form['summary'] = self.data['short']
|
|
self.form['custom_field_3'] = self.data['email']
|
|
self.form['custom_field_4'] = self.data['name']
|
|
request = self.form.click()
|
|
response2 = ClientCookie.urlopen(request)
|
|
response2.close()
|
|
|
|
def run(self):
|
|
print "1"
|
|
self.zip()
|
|
print "2"
|
|
self.login()
|
|
print "3"
|
|
self.get_form()
|
|
print "4"
|
|
self.upload()
|
|
print "5"
|
|
self.queue.put('done')
|
|
|
|
class ProgressWin(object):
|
|
def __init__(self, parent_window, no_block, queue):
|
|
self.no_block = no_block
|
|
self.queue = queue
|
|
|
|
self.win = gtk.Window()
|
|
self.win.set_type_hint('dialog')
|
|
self.win.set_title('Progress')
|
|
self.win.set_resizable(False)
|
|
self.win.set_transient_for(parent_window)
|
|
|
|
vbox = gtk.VBox()
|
|
self.text = gtk.Label('')
|
|
self.progress = gtk.ProgressBar()
|
|
self.progress.set_pulse_step(0.25)
|
|
|
|
vbox.pack_start(self.text)
|
|
vbox.pack_start(self.progress)
|
|
self.win.add(vbox)
|
|
|
|
self.win.show_all()
|
|
|
|
gtk.timeout_add(100, self.check)
|
|
|
|
def check(self):
|
|
try:
|
|
text = self.queue.get_nowait()
|
|
print text
|
|
if text == 'done':
|
|
gtk.main_quit()
|
|
self.text.set_text(text)
|
|
except Queue.Empty:
|
|
pass
|
|
|
|
self.progress.pulse()
|
|
return True
|
|
|
|
class ReportWin(object):
|
|
def start_page(self):
|
|
start = gnome.ui.DruidPageEdge(gnome.ui.EDGE_START)
|
|
start.set_text(
|
|
"""So, you want to report a bug in ardour. Excellent.
|
|
|
|
This program will help you to submit a bug report that will be useful to the programmers.
|
|
|
|
We are collecting this information so that we don't have to ask you to research very detailed aspects of your system configuration. The information this tool collects is stored in the Ardour bug tracking system, and is not used for any other purpose. We will not intentionally sell or disclose the information to any parties besides those authorized to view it on the Ardour bug tracking system.
|
|
""")
|
|
start.connect('cancel', lambda w, d: gtk.main_quit())
|
|
self.druid.append_page(start)
|
|
|
|
def end_page_finish(self, page, data):
|
|
print "page_finish"
|
|
if self.first_time:
|
|
self.first_time = False
|
|
self.druid.set_buttons_sensitive(False, False, False, False)
|
|
print "build queue"
|
|
self.queue = Queue.Queue(0)
|
|
print "build no_block"
|
|
self.no_block = NoBlock(self.data, self.queue)
|
|
print "build progress window"
|
|
self.progress = ProgressWin(self.win, self.no_block, self.queue)
|
|
print "start no block"
|
|
self.no_block.start()
|
|
print "exit end_page_finish"
|
|
|
|
def end_page(self):
|
|
end = gnome.ui.DruidPageEdge(gnome.ui.EDGE_FINISH)
|
|
end.set_text(
|
|
"""Thank you for helping Ardour.
|
|
|
|
When you click the "Apply" button, we will connect to the web and upload the information.
|
|
|
|
Please let the Bug Tool finish. It will exit on its own.""")
|
|
end.connect('cancel', lambda w, d: gtk.main_quit())
|
|
end.connect('finish', self.end_page_finish)
|
|
self.druid.append_page(end)
|
|
|
|
def build_tools_page_next(self, page, data):
|
|
if self.tools_radio.get_active():
|
|
os.system("g++ --version >> " +g_name+"/build-tools")
|
|
os.system("pkg-config --version >> " +g_name+"/build-tools")
|
|
os.system("autoconf --version >> " +g_name+"/build-tools")
|
|
os.system("automake --version >> " +g_name+"/build-tools")
|
|
os.system("aclocal --version >> " +g_name+"/build-tools")
|
|
os.system("libtool --version >> " +g_name+"/build-tools")
|
|
os.system("gettext --version >> " +g_name+"/build-tools")
|
|
os.system("autopoint --version >> " +g_name+"/build-tools")
|
|
|
|
def build_tools_page(self):
|
|
tools = gnome.ui.DruidPageStandard()
|
|
self.tools_radio = gtk.RadioButton(None, "Yes")
|
|
radio_btn2 = gtk.RadioButton(self.tools_radio, "No")
|
|
radio_btn2.set_active(True)
|
|
tools.append_item("Are you using a version of Ardour that you compiled yourself?", self.tools_radio, "")
|
|
tools.append_item("", radio_btn2, "")
|
|
tools.connect('cancel', lambda w, d: gtk.main_quit())
|
|
tools.connect('next', self.build_tools_page_next)
|
|
self.druid.append_page(tools)
|
|
|
|
def binary_page_next(self, page, data):
|
|
path = self.binary_path.get_text()
|
|
if len(path) > 0 and os.path.exists(path):
|
|
os.system("ldd "+path+" > "+g_name+"/linker-info")
|
|
|
|
def binary_page(self):
|
|
binary = gnome.ui.DruidPageStandard()
|
|
self.binary_path = gtk.Entry()
|
|
binary.append_item("Where is Ardour's binary located?", self.binary_path, "")
|
|
binary.connect('cancel', lambda w, d: gtk.main_quit())
|
|
binary.connect('next', self.binary_page_next)
|
|
self.druid.append_page(binary)
|
|
|
|
def versions_page_next(self, page, data):
|
|
os.system('echo "gtk-ardour version: '+self.gtkardour_version.get_text()+'" >>'+g_name+'/ardour-version')
|
|
os.system('echo "libardour version: '+self.libardour_version.get_text()+'" >>'+g_name+'/ardour-version')
|
|
|
|
def versions_page(self):
|
|
versions = gnome.ui.DruidPageStandard()
|
|
self.gtkardour_version = gtk.Entry()
|
|
self.libardour_version = gtk.Entry()
|
|
versions.append_item("What is gtk-ardour's version?", self.gtkardour_version, "")
|
|
versions.append_item("What is libardour's version?", self.libardour_version, "")
|
|
versions.connect('cancel', lambda w, d: gtk.main_quit())
|
|
versions.connect('next', self.versions_page_next)
|
|
self.druid.append_page(versions)
|
|
|
|
def session_check_toggled(self, data):
|
|
self.session_path.set_sensitive(self.session_check.get_active())
|
|
|
|
def sessions_page_next(self, page, data):
|
|
session = self.session_path.get_text()
|
|
if self.session_check.get_active() and session > 0:
|
|
if os.path.exists(session) and os.path.isfile(session):
|
|
shutil.copy(session, g_name)
|
|
|
|
def sessions_page(self):
|
|
sessions = gnome.ui.DruidPageStandard()
|
|
self.session_check = gtk.CheckButton("Yes")
|
|
self.session_check.set_active(True)
|
|
self.session_path = gtk.Entry()
|
|
sessions.append_item("Is the problem one you've noticed while trying to run Ardour?", self.session_check, "")
|
|
sessions.append_item("What is the session file you've been using?", self.session_path, "")
|
|
self.session_check.connect('toggled', self.session_check_toggled)
|
|
sessions.connect('cancel', lambda w, d:gtk.main_quit())
|
|
sessions.connect('next', self.sessions_page_next)
|
|
self.druid.append_page(sessions)
|
|
|
|
def description_page_next(self, page, data):
|
|
self.data['short'] = self.short_description.get_text()
|
|
buffer = self.long_description.get_buffer()
|
|
self.data['long'] = buffer.get_text(buffer.get_start_iter(), buffer.get_end_iter())
|
|
|
|
def description_page(self):
|
|
description = gnome.ui.DruidPageStandard()
|
|
self.long_description = gtk.TextView()
|
|
self.short_description = gtk.Entry()
|
|
self.long_description.set_size_request(-1, 70)
|
|
description.append_item(
|
|
"""OK, we've collected the system information. Now its time for you
|
|
to explain the problem.
|
|
|
|
Please note: you do not need to include any information about versions
|
|
of any software - that has been taken care of.
|
|
|
|
If you are reporting an operational problem, please carefully describe
|
|
the actions you took, any messages that you noticed, and in as much
|
|
detail as possible describe what went wrong.""", self.long_description, "")
|
|
description.append_item("Please give a one line summary of your problem", self.short_description, "")
|
|
description.connect('cancel', lambda w, d:gtk.main_quit())
|
|
description.connect('next', self.description_page_next)
|
|
self.druid.append_page(description)
|
|
|
|
def info_page_next(self, page, data):
|
|
self.data['name'] = self.name.get_text()
|
|
self.data['email'] = self.email.get_text()
|
|
|
|
def info_page(self):
|
|
info = gnome.ui.DruidPageStandard()
|
|
self.name = gtk.Entry()
|
|
self.email = gtk.Entry()
|
|
info.append_item("Name", self.name, "Optional")
|
|
info.append_item("Email", self.email, "")
|
|
info.connect('cancel', lambda w, d:gtk.main_quit())
|
|
info.connect('next', self.info_page_next)
|
|
self.druid.append_page(info)
|
|
|
|
def __init__(self):
|
|
self.first_time = True
|
|
|
|
self.win = gtk.Window()
|
|
self.win.set_title("Ardour Bug Tool")
|
|
self.win.connect('destroy', lambda w: gtk.main_quit())
|
|
|
|
self.druid = gnome.ui.Druid()
|
|
|
|
self.start_page()
|
|
self.build_tools_page()
|
|
self.binary_page()
|
|
self.versions_page()
|
|
self.sessions_page()
|
|
self.description_page()
|
|
self.info_page()
|
|
self.end_page()
|
|
|
|
self.win.add(self.druid)
|
|
self.win.show_all()
|
|
|
|
self.data = {}
|
|
|
|
def main(*args):
|
|
os.mkdir(g_name+"/proc/")
|
|
proclist = ['asound', 'cpuinfo', 'devices', 'dma', 'filesystems', 'irq', 'isapnp', 'meminfo', 'modules', 'mounts', 'partition', 'pci', 'slabinfo', 'sysvipc/shm', 'version']
|
|
for item in proclist:
|
|
if os.path.exists('/proc/'+item):
|
|
try:
|
|
if os.path.isdir('/proc/'+item):
|
|
shutil.copytree('/proc/'+item, g_name+'/proc/'+item)
|
|
else:
|
|
shutil.copy('/proc/'+item, g_name+'/proc/')
|
|
except shutil.Error:
|
|
pass #should this be reported?
|
|
else:
|
|
f = open(g_name+'/proc/'+item, 'w')
|
|
f.write(item+' missing in /proc')
|
|
f.close
|
|
|
|
liblist = ['asound', 'c', 'gdbm', 'gdk', 'gmodule', 'gtk', 'intl', 'jack', 'm', 'pthreads', 'sndfile', 'X11', 'Xext']
|
|
for lib in liblist:
|
|
for libdir in ['/lib/', '/usr/lib/', '/usr/X11R6/lib/', '/usr/local/lib/', '/opt/lib/']:
|
|
if os.path.exists(libdir+"lib"+lib+".so"):
|
|
os.system('echo "'+lib+ ' is `ls -l '+libdir+'lib'+lib+'.so`" >> '+g_name+'/libraries')
|
|
|
|
if os.path.exists('/proc/sys/kernel/lowlatency'):
|
|
shutil.copy('/proc/sys/kernel/lowlatency', g_name+'/lowlatency-status')
|
|
else:
|
|
f = open(g_name+'/lowlatency-status', 'w')
|
|
f.write('-1')
|
|
f.close()
|
|
|
|
scsi = re.compile(r'sd[a-z][0-9]')
|
|
if scsi.search(open('/proc/mounts').read()):
|
|
shutil.copytree('/proc/scsi', g_name+'/scsi')
|
|
|
|
ide = re.compile(r'hd[a-z][0-9]')
|
|
if ide.search(open('/proc/mounts').read()):
|
|
pass
|
|
|
|
os.system("xmodmap >" +g_name+"/xmodmap")
|
|
os.system("/sbin/lspci -vv >" +g_name+"/lspci.out")
|
|
|
|
if os.path.exists(os.path.expandvars('$HOME')+'/.ardour/ardour.rc'):
|
|
shutil.copy(os.path.expandvars('$HOME')+'/.ardour/ardour.rc', g_name+'/ardour.rc')
|
|
|
|
bug_win = ReportWin()
|
|
|
|
gtk.main()
|
|
|
|
if __name__ == '__main__':
|
|
main()
|
|
|
|
shutil.rmtree(g_name)
|
|
if os.path.exists(g_name+'.tar.gz'):
|
|
os.remove(g_name+'.tar.gz')
|
|
|