class TableEditor(ListWin):
def __init__(self,
conn,
table,
pkey=None,
fields=[],
command_data=dict(new='new entry', edit='edit entry')):
ListWin.__init__(self)
self.conn = conn
self.cursor = StatementCursor(self.conn)
self.cursor.set_table(table)
self._cdata = command_data
self.tbar.add_button('new', self._cdata['new'],
self.toolbar_button_pressed)
self.tbar.add_button('edit', self._cdata['edit'],
self.toolbar_button_pressed)
if pkey is None:
print get_pkey_info(StatementCursor(conn), table)
self._pkey = pkey
self.reset_rows()
self._fields = fields
self.fields = [pkey] + self._fields
self.dialogs = {}.fromkeys(self._cdata.keys())
def reset_rows(self):
self.set_rows(self.cursor.select(order=self._pkey))
def toolbar_button_pressed(self, button, data):
row = None
if data == 'new':
if self.dialogs['new'] is None:
row = self.cursor.select()[0]
self._make_dialog('new', row, self.add_new_record)
elif data == 'edit':
if self.dialogs['edit'] is None:
row = get_single_row(self.listbox, self._pkey)
if row is not None:
self._make_dialog('edit', row, self.edit_record,
row[self._pkey])
def _make_dialog(self, name, row, okfun, pkey=None):
if name == 'edit':
fields = self._fields
else:
fields = self.fields
make_record_dialog(self, name, row, okfun, pkey, fields, self._cdata)
def add_new_record(self, *args):
dialog = self.dialogs['new']
self.cursor.insert(data=dict(dialog.items()))
self.destroy_dialog(dialog)
self.reset_rows()
def edit_record(self, *args):
dialog = self.dialogs['edit']
clause = Eq(self._pkey, dialog.pkey)
data = dict(dialog.items())
self.cursor.update(data=data, clause=clause)
self.destroy_dialog(dialog)
self.reset_rows()
class TraitsWindow(DragListWindow):
def __init__(self, conn, suite, name='TraitsWindow'):
self.cmd = StatementCursor(conn, name=name)
self.cmd.set_table(ujoin(suite, 'traits'))
rows = self.cmd.select()
packer = lambda x : rowpacker('trait', x)
DragListWindow.__init__(self, '%s traits' % suite, packer, rows,
TARGETS.get('trait', suite), name=name)
self.set_size_request(400, 300)
class TableEditor(ListWin):
def __init__(self, conn, table, pkey=None, fields=[],
command_data=dict(new='new entry', edit='edit entry')):
ListWin.__init__(self)
self.conn = conn
self.cursor = StatementCursor(self.conn)
self.cursor.set_table(table)
self._cdata = command_data
self.tbar.add_button('new', self._cdata['new'], self.toolbar_button_pressed)
self.tbar.add_button('edit', self._cdata['edit'], self.toolbar_button_pressed)
if pkey is None:
print get_pkey_info(StatementCursor(conn), table)
self._pkey = pkey
self.reset_rows()
self._fields = fields
self.fields = [pkey] + self._fields
self.dialogs = {}.fromkeys(self._cdata.keys())
def reset_rows(self):
self.set_rows(self.cursor.select(order=self._pkey))
def toolbar_button_pressed(self, button, data):
row = None
if data == 'new':
if self.dialogs['new'] is None:
row = self.cursor.select()[0]
self._make_dialog('new', row, self.add_new_record)
elif data == 'edit':
if self.dialogs['edit'] is None:
row = get_single_row(self.listbox, self._pkey)
if row is not None:
self._make_dialog('edit', row, self.edit_record, row[self._pkey])
def _make_dialog(self, name, row, okfun, pkey=None):
if name == 'edit':
fields = self._fields
else:
fields = self.fields
make_record_dialog(self, name, row, okfun, pkey, fields, self._cdata)
def add_new_record(self, *args):
dialog = self.dialogs['new']
self.cursor.insert(data=dict(dialog.items()))
self.destroy_dialog(dialog)
self.reset_rows()
def edit_record(self, *args):
dialog = self.dialogs['edit']
clause = Eq(self._pkey, dialog.pkey)
data = dict(dialog.items())
self.cursor.update(data=data, clause=clause)
self.destroy_dialog(dialog)
self.reset_rows()
class TextFileBrowser(ListTextView):
def __init__(self, conn, name='TextFileBrowser'):
ListTextView.__init__(self, name=name)
self.conn = conn
self.cursor = StatementCursor(self.conn)
self.cursor.set_table('textfiles')
def reset_rows(self):
self.set_rows(self.cursor.select(fields=['fileid']))
self.set_row_select(self.fileid_selected)
def fileid_selected(self, listbox, row, column, event):
pass
class TextFileBrowser(ListTextView):
def __init__(self, conn, name='TextFileBrowser'):
ListTextView.__init__(self, name=name)
self.conn = conn
self.cursor = StatementCursor(self.conn)
self.cursor.set_table('textfiles')
def reset_rows(self):
self.set_rows(self.cursor.select(fields=['fileid']))
self.set_row_select(self.fileid_selected)
def fileid_selected(self, listbox, row, column, event):
pass
class BaseRelationalBrowser(ListNoteBook, HasDialogs):
def __init__(self, conn, maintable, pkey):
self.menu = make_menu(['insert', 'update', 'done'], self.pkey_command)
ListNoteBook.__init__(self)
self.conn = conn
self.main = StatementCursor(self.conn)
self.main.set_table(maintable)
self.pkey = pkey
self.dialogs = {}.fromkeys(['insert', 'update', 'delete'])
self.relations = {}
def reset_rows(self):
self.set_rows(self.main.select(order=self.pkey))
self.set_row_select(self.pkey_selected)
def pkey_selected(self, listbox, row, column, event):
print listbox.get_selected_data()[0][0]
def pkey_command(self, menuitem, command):
if command == 'insert':
if self.dialogs['insert'] is None:
dialog = dialogs.Entry('insert a %s' % self.pkey,
name='insert')
dialog.set_ok(self.pkey_insert_ok)
dialog.set_cancel(self.destroy_dialog)
self.dialogs['insert'] = dialog
elif command == 'update':
dialogs.Message('need to set update to cascade in db')
elif command == 'done':
value = None
try:
value = self.listbox.get_selected_data()[0][0]
except IndexError:
dialogs.Message('need to select %s first' % self.pkey)
if value is not None:
dialogs.Message('ok, i am done.')
def append_relation(self, table, fields=[], fkeyname=None):
if table not in self.relations:
if not fields:
if fkeyname is None:
fkeyname = self.pkey
fields = [f for f in self.main.fields(table) if f != fkeyname]
if fkeyname is None:
fkeyname = self.pkey
self.relations[table] = fkeyname, fields
else:
raise Error, "relation already exists %s" % table
class BaseRelationalBrowser(ListNoteBook, HasDialogs):
def __init__(self, conn, maintable, pkey):
self.menu = make_menu(["insert", "update", "done"], self.pkey_command)
ListNoteBook.__init__(self)
self.conn = conn
self.main = StatementCursor(self.conn)
self.main.set_table(maintable)
self.pkey = pkey
self.dialogs = {}.fromkeys(["insert", "update", "delete"])
self.relations = {}
def reset_rows(self):
self.set_rows(self.main.select(order=self.pkey))
self.set_row_select(self.pkey_selected)
def pkey_selected(self, listbox, row, column, event):
print listbox.get_selected_data()[0][0]
def pkey_command(self, menuitem, command):
if command == "insert":
if self.dialogs["insert"] is None:
dialog = dialogs.Entry("insert a %s" % self.pkey, name="insert")
dialog.set_ok(self.pkey_insert_ok)
dialog.set_cancel(self.destroy_dialog)
self.dialogs["insert"] = dialog
elif command == "update":
dialogs.Message("need to set update to cascade in db")
elif command == "done":
value = None
try:
value = self.listbox.get_selected_data()[0][0]
except IndexError:
dialogs.Message("need to select %s first" % self.pkey)
if value is not None:
dialogs.Message("ok, i am done.")
def append_relation(self, table, fields=[], fkeyname=None):
if table not in self.relations:
if not fields:
if fkeyname is None:
fkeyname = self.pkey
fields = [f for f in self.main.fields(table) if f != fkeyname]
if fkeyname is None:
fkeyname = self.pkey
self.relations[table] = fkeyname, fields
else:
raise Error, "relation already exists %s" % table
class MountsElement(Element):
def __init__(self, conn):
Element.__init__(self, 'mounts')
self.conn = conn
self.cursor = StatementCursor(self.conn)
self.cursor.set_table('mounts')
self.mounts = []
rows = self.cursor.select(order='mnt_name')
for r in rows:
self.append_mount(r.mnt_name, r.mnt_point, r.fstype, r.mnt_opts,
r.dump, r['pass'])
def append_mount(self, mnt_name, mnt_point, fstype, mnt_opts, dump, pass_):
mnt_element = MountElement(mnt_name, mnt_point, fstype, mnt_opts, dump,
pass_)
self.mounts.append(mnt_element)
self.appendChild(mnt_element)
class EnvironmentList(KListView):
def __init__(self, app, parent, etype='default', name='EnvironmentList'):
KListView.__init__(self, parent, name)
dbwidget(self, app)
self.etype = etype
self.environ = ETYPE[self.etype](self.conn)
self.cursor = StatementCursor(self.conn)
self.cursor.set_table('%s_environment' % self.etype)
self.setRootIsDecorated(True)
for field in ['section', 'option', 'value']:
self.addColumn(field)
def refreshlistView(self):
self.clear()
if self.etype == 'default':
fields = ['section', 'option', 'value']
rows = self.cursor.select(fields=fields,
order=['section', 'option'])
if self.etype == 'current':
fields = ['hostname', 'name', 'value']
rows = self.cursor.select(fields=fields,
order=['hostname', 'name'])
for row in rows:
KListViewItem(self, *row)
def file_selected(self, filesel):
filename = str(filesel.selectedFile())
print filename, filesel.actiontype
action = filesel.actiontype
if action == 'save':
self.environ.write(file(filename, 'w'))
elif action == 'load':
newcfg = RawConfigParser()
newcfg.read(filename)
self._update_environ(newcfg)
def _update_environ(self, newcfg):
self.environ.update(newcfg)
self.environ = ETYPE[self.etype](self.conn)
self.refreshlistView()
def slotEdit(self):
newcfg = self.environ.edit()
self._update_environ(newcfg)
class Profile(StatementCursor):
def __init__(self, conn):
StatementCursor.__init__(self, conn)
self.conn = conn
self.set_table('profiles')
self._traits = ProfileTrait(conn)
self._env = ProfileEnvironment(conn)
self._pfam = StatementCursor(conn)
self._pfam.set_table('profile_family')
self._fam = Family(conn)
def drop_profile(self, profile):
self.delete(clause=Eq('profile', profile))
def set_profile(self, profile):
self.clause = Eq('profile', profile)
self.current = self.select_row(clause=self.clause)
self._traits.set_profile(profile)
self._env.set_profile(profile)
def get_profile_data(self):
return self._env.ProfileData()
def get_family_data(self):
families = self.get_families()
return self._fam.FamilyData(families)
def make_traitlist(self, log=None):
tp = TraitParent(self.conn, self.current.suite)
listed = [x.trait for x in self._traits.trait_rows()]
all = list(tp.get_traitset(listed))
setfun = tp.set_trait
parfun = tp.parents
return make_deplist(listed, all, setfun, parfun, log)
def family_rows(self, profile=None):
if profile is None:
profile = self.current.profile
return self._pfam.select(clause=Eq('profile', profile))
def get_families(self, profile=None):
return [r.family for r in self.family_rows(profile)]
class FilesystemElement(Element):
def __init__(self, conn, filesystem):
Element.__init__(self, 'filesystem')
self.conn = conn
self.cursor = StatementCursor(self.conn)
self.cursor.set_table('filesystem_mounts')
self.setAttribute('name', filesystem)
self.mounts = []
self.filesystem = filesystem
clause = Eq('filesystem', filesystem)
rows = self.cursor.select(clause=clause, order='mnt_name')
for r in rows:
self.append_fs_mount(r.mnt_name, r.ord, r.partition)
def append_fs_mount(self, mnt_name, ord, partition):
fs_mount_element = FilesystemMountElement(mnt_name, str(ord), str(partition))
self.mounts.append(fs_mount_element)
self.appendChild(fs_mount_element)
class PackageDoc(BaseDocument):
def __init__(self, app, **atts):
BaseDocument.__init__(self, app, **atts)
self.suite = None
self.cursor = StatementCursor(self.conn)
def set_suite(self, suite):
self.suite = suite
self.cursor.set_table('%s_packages' % self.suite)
def set_clause(self, clause):
print 'clause---->', clause, type(clause)
self.cursor.clause = clause
self.clear_body()
title = SimpleTitleElement('%s Packages' % self.suite, bgcolor='IndianRed', width='100%')
self.body.appendChild(title)
for row in self.cursor.select(clause=clause):
self.body.appendChild(PackageFieldTable(row, bgcolor='MistyRose2'))
self.body.appendChild(HR())
class PackageDoc(BaseDocument):
def __init__(self, app, **atts):
BaseDocument.__init__(self, app, **atts)
self.suite = None
self.cursor = StatementCursor(self.conn)
def set_suite(self, suite):
self.suite = suite
self.cursor.set_table('%s_packages' % self.suite)
def set_clause(self, clause):
print 'clause---->', clause, type(clause)
self.cursor.clause = clause
self.clear_body()
title = SimpleTitleElement('%s Packages' % self.suite, bgcolor='IndianRed', width='100%')
self.body.appendChild(title)
for row in self.cursor.select(clause=clause):
self.body.appendChild(PackageFieldTable(row, bgcolor='MistyRose2'))
self.body.appendChild(HR())
class DefEnvEditor(CommandBoxWindow):
def __init__(self, conn):
CommandBoxWindow.__init__(self)
self.conn = conn
self.defenv = DefaultEnvironment(self.conn)
self.add_menu(['load', 'edit', 'save'], 'main',
self.main_menu_selected)
self.cursor = StatementCursor(self.conn)
self.cursor.set_table('default_environment')
self.view = ScrollCList()
self.vbox.add(self.view)
self.reset_rows()
def reset_rows(self):
self.view.set_rows(self.cursor.select(order=['section', 'option']))
def main_menu_selected(self, menuitem, name):
if name == 'edit':
newcfg = self.defenv.edit()
self._update_dfenv(newcfg)
elif name in ['load', 'save']:
filesel = FileSelection(title='%s Default Environment' % name)
filesel.cancel_button.connect('clicked',
lambda x: filesel.destroy())
filesel.show()
filesel.ok_button.connect('clicked', self.ok_filesel, filesel)
filesel.set_data('action', name)
def ok_filesel(self, button, filesel):
path = filesel.get_filename()
action = filesel.get_data('action')
filesel.destroy()
if action == 'save':
self.defenv.write(file(path, 'w'))
elif action == 'load':
newcfg = RawConfigParser()
newcfg.read(path)
self._update_dfenv(newcfg)
def _update_dfenv(self, newcfg):
self.defenv.update(newcfg)
self.defenv = DefaultEnvironment(self.conn)
self.reset_rows()
class TraitsElement(Element):
def __init__(self, conn, suite):
Element.__init__(self, 'traits')
self.conn = conn
self.suite = suite
self.setAttribute('suite', self.suite)
self._traits_ = StatementCursor(self.conn, 'Traits')
self._traits_.set_table(ujoin(self.suite, 'traits'))
self.traitnames = [row.trait for row in self._traits_.select(order='trait')]
for t in self.traitnames:
t_element = Element('trait')
t_element.setAttribute('name', t)
self.appendChild(t_element)
def make_trait(self, trait):
t_element = TraitElement(self.conn, self.suite)
t_element.set(trait)
return t_element
class TraitsElement(Element):
def __init__(self, conn, suite):
Element.__init__(self, 'traits')
self.conn = conn
self.suite = suite
self.setAttribute('suite', self.suite)
self._traits_ = StatementCursor(self.conn, 'Traits')
self._traits_.set_table(ujoin(self.suite, 'traits'))
self.traitnames = [row.trait for row in self._traits_.select(order='trait')]
for t in self.traitnames:
t_element = Element('trait')
t_element.setAttribute('name', t)
self.appendChild(t_element)
def make_trait(self, trait):
t_element = TraitElement(self.conn, self.suite)
t_element.set(trait)
return t_element
class EnvironmentList(KListView):
def __init__(self, app, parent, etype='default', name='EnvironmentList'):
KListView.__init__(self, parent, name)
dbwidget(self, app)
self.etype = etype
self.environ = ETYPE[self.etype](self.conn)
self.cursor = StatementCursor(self.conn)
self.cursor.set_table('%s_environment' % self.etype)
self.setRootIsDecorated(True)
for field in ['section', 'option', 'value']:
self.addColumn(field)
def refreshlistView(self):
self.clear()
if self.etype == 'default':
fields = ['section', 'option', 'value']
rows = self.cursor.select(fields=fields, order=['section', 'option'])
if self.etype == 'current':
fields = ['hostname', 'name', 'value']
rows = self.cursor.select(fields=fields, order=['hostname', 'name'])
for row in rows:
KListViewItem(self, *row)
def file_selected(self, filesel):
filename = str(filesel.selectedFile())
print filename, filesel.actiontype
action = filesel.actiontype
if action == 'save':
self.environ.write(file(filename, 'w'))
elif action == 'load':
newcfg = RawConfigParser()
newcfg.read(filename)
self._update_environ(newcfg)
def _update_environ(self, newcfg):
self.environ.update(newcfg)
self.environ = ETYPE[self.etype] (self.conn)
self.refreshlistView()
def slotEdit(self):
newcfg = self.environ.edit()
self._update_environ(newcfg)
class FilesystemElement(Element):
def __init__(self, conn, filesystem):
Element.__init__(self, 'filesystem')
self.conn = conn
self.cursor = StatementCursor(self.conn)
self.cursor.set_table('filesystem_mounts')
self.setAttribute('name', filesystem)
self.mounts = []
self.filesystem = filesystem
clause = Eq('filesystem', filesystem)
rows = self.cursor.select(clause=clause, order='mnt_name')
for r in rows:
self.append_fs_mount(r.mnt_name, r.ord, r.partition)
def append_fs_mount(self, mnt_name, ord, partition):
fs_mount_element = FilesystemMountElement(mnt_name, str(ord),
str(partition))
self.mounts.append(fs_mount_element)
self.appendChild(fs_mount_element)
class Profile(StatementCursor):
def __init__(self, conn):
StatementCursor.__init__(self, conn)
self.conn = conn
self.set_table('profiles')
self._traits = ProfileTrait(conn)
self._env = ProfileEnvironment(conn)
self._pfam = StatementCursor(conn)
self._pfam.set_table('profile_family')
self._fam = Family(conn)
def drop_profile(self, profile):
self.delete(clause=Eq('profile', profile))
def set_profile(self, profile):
self.clause = Eq('profile', profile)
self.current = self.select_row(clause=self.clause)
self._traits.set_profile(profile)
self._env.set_profile(profile)
def get_profile_data(self):
return self._env.ProfileData()
def get_family_data(self):
families = self.get_families()
return self._fam.FamilyData(families)
def make_traitlist(self, log=None):
tp = TraitParent(self.conn, self.current.suite)
listed = [x.trait for x in self._traits.trait_rows()]
all = list(tp.get_traitset(listed))
setfun = tp.set_trait
parfun = tp.parents
return make_deplist(listed, all, setfun, parfun, log)
def family_rows(self, profile=None):
if profile is None:
profile = self.current.profile
return self._pfam.select(clause=Eq('profile', profile))
def get_families(self, profile=None):
return [r.family for r in self.family_rows(profile)]
class DefEnvEditor(CommandBoxWindow):
def __init__(self, conn):
CommandBoxWindow.__init__(self)
self.conn = conn
self.defenv = DefaultEnvironment(self.conn)
self.add_menu(['load', 'edit', 'save'], 'main', self.main_menu_selected)
self.cursor = StatementCursor(self.conn)
self.cursor.set_table('default_environment')
self.view = ScrollCList()
self.vbox.add(self.view)
self.reset_rows()
def reset_rows(self):
self.view.set_rows(self.cursor.select(order=['section', 'option']))
def main_menu_selected(self, menuitem, name):
if name == 'edit':
newcfg = self.defenv.edit()
self._update_dfenv(newcfg)
elif name in ['load', 'save']:
filesel = FileSelection(title='%s Default Environment' % name)
filesel.cancel_button.connect('clicked',
lambda x: filesel.destroy())
filesel.show()
filesel.ok_button.connect('clicked', self.ok_filesel, filesel)
filesel.set_data('action', name)
def ok_filesel(self, button, filesel):
path = filesel.get_filename()
action = filesel.get_data('action')
filesel.destroy()
if action == 'save':
self.defenv.write(file(path, 'w'))
elif action == 'load':
newcfg = RawConfigParser()
newcfg.read(path)
self._update_dfenv(newcfg)
def _update_dfenv(self, newcfg):
self.defenv.update(newcfg)
self.defenv = DefaultEnvironment(self.conn)
self.reset_rows()
class MountsElement(Element):
def __init__(self, conn):
Element.__init__(self, 'mounts')
self.conn = conn
self.cursor = StatementCursor(self.conn)
self.cursor.set_table('mounts')
self.mounts = []
rows = self.cursor.select(order='mnt_name')
for r in rows:
self.append_mount(r.mnt_name, r.mnt_point, r.fstype,
r.mnt_opts, r.dump, r['pass'])
def append_mount(self, mnt_name, mnt_point, fstype,
mnt_opts, dump, pass_):
mnt_element = MountElement(mnt_name, mnt_point, fstype,
mnt_opts, dump, pass_)
self.mounts.append(mnt_element)
self.appendChild(mnt_element)
class TextFileManager(object):
def __init__(self, conn):
object.__init__(self)
self.conn = conn
self.cursor = StatementCursor(self.conn)
self.cursor.set_table('textfiles')
def insert_file(self, datafile):
md5 = self._md5sum(datafile)
data = datafile.read()
md5size = '_'.join([md5, str(len(data))])
return self._insert_data(md5size, data)
def insert_data(self, data):
md5 = md5sum(strfile(data))
md5size = '_'.join([md5, str(len(data))])
return self._insert_data(md5size, data)
def _insert_data(self, md5size, data):
clause=Eq('md5size', md5size)
try:
row = self.cursor.select_row(clause=clause)
except NoExistError:
row = None
if not row:
self.cursor.insert(data={'md5size' : md5size, 'data' : data})
row = self.cursor.select_row(clause=clause)
return row.fileid
def get_data(self, id):
row = self.cursor.select_row(clause=Eq('fileid', id))
return row.data
def get_strfile(self, id):
return strfile(self.get_data(id))
def _md5sum(self, datafile):
datafile.seek(0)
md5 = md5sum(datafile)
datafile.seek(0)
return md5
class TextFileManager(object):
def __init__(self, conn):
object.__init__(self)
self.conn = conn
self.cursor = StatementCursor(self.conn)
self.cursor.set_table('textfiles')
def insert_file(self, datafile):
md5 = self._md5sum(datafile)
data = datafile.read()
md5size = '_'.join([md5, str(len(data))])
return self._insert_data(md5size, data)
def insert_data(self, data):
md5 = md5sum(strfile(data))
md5size = '_'.join([md5, str(len(data))])
return self._insert_data(md5size, data)
def _insert_data(self, md5size, data):
clause = Eq('md5size', md5size)
try:
row = self.cursor.select_row(clause=clause)
except NoExistError:
row = None
if not row:
self.cursor.insert(data={'md5size': md5size, 'data': data})
row = self.cursor.select_row(clause=clause)
return row.fileid
def get_data(self, id):
row = self.cursor.select_row(clause=Eq('fileid', id))
return row.data
def get_strfile(self, id):
return strfile(self.get_data(id))
def _md5sum(self, datafile):
datafile.seek(0)
md5 = md5sum(datafile)
datafile.seek(0)
return md5
class ScriptBrowser(ListNoteBook):
def __init__(self, conn, suite, trait):
self.conn = conn
self.suite = suite
self.trait = trait
self.cursor = StatementCursor(self.conn)
self.cursor.set_table('%s_scripts' % self.suite)
self.edit_menu = make_menu(SCRIPTS, self.modify_trait, name='edit')
self.diff_menu = make_menu(SCRIPTS, self.modify_trait, name='diff')
self.menu = make_menu(['edit', 'diff'], self.modify_trait)
self.menu['edit'].set_submenu(self.edit_menu)
self.menu['diff'].set_submenu(self.diff_menu)
self.menu.set_name('main')
ListNoteBook.__init__(self)
self.reset_rows()
def reset_rows(self):
rows = self.cursor.select(fields=['script'], clause=self._trait_clause())
self.set_rows(rows)
self.set_row_select(self.script_selected)
def modify_trait(self, menuitem, action):
parent = menuitem.get_parent().get_name()
if parent == '_none_':
print 'ack ack ack'
elif parent != 'main':
print parent, action
def _trait_clause(self):
return Eq('trait', self.trait)
def script_selected(self, listbox, row, column, event):
script = listbox.get_selected_data()[0].script
self.select_script(script)
def select_script(self, script):
if script not in self.pages:
newpage = ScriptText(self.conn, self.suite, self.trait, script)
self.append_page(newpage, script)
self.set_current_page(script)
class PackagesWindow(DragListWindow):
def __init__(self, conn, suite, name='PackagesWindow'):
self.cmd = StatementCursor(conn, name=name)
table = ujoin(suite, 'packages')
self.cmd.set_table(table)
section_query ='select distinct section from %s' % table
sections = [x.section for x in self.cmd.get(section_query)]
self.section_combo = MyCombo(sections)
self.section_combo.set(sections[0])
rows = self.cmd.select(clause="section = '%s'" % sections[0])
packer = lambda x : rowpacker('package', x)
DragListWindow.__init__(self, '%s packages' % suite, packer, rows,
TARGETS.get('package', suite), name=name)
self.vbox.pack_start(self.section_combo,0,0,0)
self.set_size_request(400, 300)
self.set_ok(self.set_packages)
def set_packages(self, *args):
section = self.section_combo.get()
fields = ['package', 'priority', 'version', 'installedsize',
'maintainer', 'size']
rows = self.cmd.select(fields=fields, clause=Eq('section', section))
self.set_rows(rows)
self.set_select_mode('multi')
class RepositoryManager(object):
def __init__(self, conn):
self.conn = conn
self.main = StatementCursor(self.conn, 'RepositoryMain')
self.repos = StatementCursor(self.conn, 'Repository')
self.repos.set_table('repository')
self.sources = StatementCursor(self.conn, 'Sources')
self.sources.set_table('sources')
self.release = ReleaseCursor(self.conn)
self.repsections = StatementCursor(self.conn, 'repos_section')
self.repsections.set_table('repos_section')
self.__init_db__()
def __init_db__(self):
if not len(self.main.tables()):
map(self.main.create_table, primary_tables())
def drop_source(self, name, type):
nameclause = Eq('name', name)
clause = nameclause & Eq('type', type)
for section in self.get_sections(name):
self.main.drop(list_tablename(name, type, section))
self.sources.delete(clause=clause)
sources = self.sources.select(clause=clause)
if not len(sources):
self.repsections.delete(clause=nameclause)
self.repos.delete(clause=nameclause)
def add_source(self, name, source):
source = make_source(source)
if name not in [x.name for x in self.repos.select()]:
self.repos.insert(data=dict(name=name))
clause = Eq('name', name) & Eq('type', source.type)
count = int(self.sources.select(fields=['count(name)'], clause=clause)[0][0])
if count == 0:
if islocaluri(source.uri):
data = dict(name=name, type=source.type, uri=source.uri,
suite=source.suite)
self.sources.insert(data=data)
current_sections = self.get_sections(name)
sdata = dict(name=name, section=None)
for section in source.sections:
if section not in current_sections:
sdata['section'] = section
self.repsections.insert(data=sdata)
fullparse = FullParseTable(name, source.type, section)
if fullparse.name not in self.main.tables():
self.main.create_table(fullparse)
listtable = ListTable(name, source.type, section)
if listtable.name not in self.main.tables():
self.main.create_table(listtable)
else:
raise Error, 'local uris first'
else:
if not islocaluri(source.uri):
data = dict(remote=source.uri)
self.sources.update(data=data, clause=clause)
else:
raise ExistsError, 'already there'
def get_sections(self, name):
clause = Eq('name', name)
return [x.section for x in self.repsections.iselect(fields=['section'], clause=clause)]
def make_source_line(self, name, type, remote=False):
repsrc = self.make_source(name, type, remote)
return str(repsrc)
def make_source(self, name, type, remote=False):
clause = Eq('name', name) & Eq('type', type)
source = self.sources.select_row(clause=clause)
repsrc = RepositorySource()
repsrc.type = source.type
if remote:
repsrc.uri = source.remote
else:
repsrc.uri = source.uri
repsrc.suite = source.suite
repsrc.sections = self.get_sections(name)
repsrc.set_path()
return repsrc
def listfile(self, name, type, section=None):
source = self.make_source(name, type)
release = Release(source)
print 'Need to pull from database!!!'
if source.has_release():
return join(source.distpath, release.path(section))
else:
return join(source.distpath, source.listfile())
def get_remote(self, name, type, remote=True):
return self.make_source(name, type, remote=True)
def parse_section(self, name, type, section=None):
listfile = self.listfile(name, type, section)
debug(listfile)
if not isfile(listfile):
raise NoFileError, 'file not there'
if type == 'deb':
return full_parse(listfile)
elif type == 'deb-src':
return parse_sources(listfile)
else:
raise Error, 'bad source type'
def add_repository(self, name):
self.repos.insert(data=dict(name=name))
class RelationalBrowser(ListNoteBook, HasDialogs):
def __init__(self, conn, maintable, reltable, pkey, fields):
self.menu = make_menu(['insert', 'update', 'done'], self.pkey_command)
ListNoteBook.__init__(self)
self.conn = conn
self.main = StatementCursor(self.conn)
self.main.set_table(maintable)
self.rel = StatementCursor(self.conn)
self.rel.set_table(reltable)
self.pkey = pkey
self._fields = fields
self.fields = [self.pkey] + self._fields
self.reset_rows()
self.dialogs = {}.fromkeys(['insert', 'update', 'delete'])
self.relmenu = make_menu(['insert', 'update', 'delete'],
self.relmenu_command)
def reset_rows(self):
self.set_rows(self.main.select(order=self.pkey))
self.set_row_select(self.pkey_selected)
def pkey_selected(self, listbox, row, column, event):
value = listbox.get_selected_data()[0][0]
self.current_value = value
if value not in self.pages:
rows = self.rel.select(clause=Eq(self.pkey, value),
order=self.pkey)
rtable = ScrollCList(rcmenu=self.relmenu)
rtable.set_rows(rows)
self.append_page(rtable, value)
self.set_current_page(value)
def pkey_insert_ok(self, *args):
dialog = self.dialogs['insert']
value = dialog.get()
print value
try:
self.main.insert(data={self.pkey: value})
inserted = True
except OperationalError:
dialogs.Message('bad query\n%s is not allowed' % value)
if inserted:
self.destroy_dialog(dialog)
self.reset_rows()
def relmenu_command(self, menuitem, command):
print command
if command in ['insert', 'update', 'delete']:
if self.dialogs[command] is None:
clause = Eq(self.pkey, self.current_value)
try:
row = self.rel.select(clause=clause)[0]
except IndexError:
row = dict.fromkeys(self.fields)
row[self.pkey] = self.current_value
if command in ['insert', 'delete']:
fields = self.fields
clause = None
else:
fields = self._fields
clause = Eq(self.pkey, self.current_value)
make_record_dialog(self, command, row,
self.relmenu_command_selected, self.pkey,
fields, {command: command})
print self.dialogs.items()
def relmenu_command_selected(self, button, *data):
command = button.get_name()
dialog = self.dialogs[command]
items = dialog.items()
if command == 'insert':
self.rel.insert(data=dict(items))
elif command == 'delete':
print 'delete delete delete delete'
clause = SimpleClause(items, '=', 'and')
dialogs.Message(self.rel.stmt.delete(clause=clause))
if False:
dialog = self.dialogs['insert']
print dialog
items = dialog.items()
print items
self.rel.insert(data=dict(items))
self.destroy_dialog(dialog)
self.reset_rows()
class ProfileGenWin(CommandBoxWindow):
def __init__(self, conn, name='ProfileGenWin'):
actions = ['create', 'copy', 'export', 'import']
CommandBoxWindow.__init__(self, name=name)
self.set_title(name)
self.conn = conn
self.cmd = StatementCursor(conn, name)
self.suites = [x.suite for x in self.cmd.select(table='suites')]
self.profiles = StatementCursor(conn, 'profiles')
self.profiles.set_table('profiles')
self.menu_bar = SimpleMenuBar()
self.vbox.pack_start(self.menu_bar, 0, 0, 0)
self.dialogs = {}.fromkeys(actions)
self.add_menu(actions, 'main', self.ask_dialog)
self.add_menu(self.suites, 'traits', self.show_traits)
self.add_menu(self.suites, 'traitgen', self.show_traitgen)
self.browser = ProfileBrowser(self.conn, self.suites)
self.vbox.add(self.browser)
self.set_size_request(400, 300)
def ask_dialog(self, button, data):
if not self.dialogs[data]:
if data == 'create':
self.dialogs[data] = dialogs.Entry('create profile', name='create')
self.dialogs[data].set_ok(self.create_profile)
elif data == 'copy':
self.dialogs[data] = dialogs.CList('copy profile', name='copy')
dialog = self.dialogs[data]
dialog.set_rows(self.profiles.select(fields='profile', order='profile'))
dialog.set_ok(self.src_profile_selected)
elif data == 'export':
pdb = PaellaDatabase(self.conn)
profiles = pdb.profiles
self.dialogs[data].set_cancel(self.destroy_dialog)
def destroy_dialog(self, dying):
name = dying.get_name()
self.dialogs[name] = None
dying.destroy()
def create_profile(self, button):
name = button.get_name()
debug(name)
if name == 'create':
profile = self.dialogs[name].get()
if profile not in [p.profile for p in self.profiles.select()]:
self.profiles.insert(data={'profile' : profile,
'suite' : 'woody'})
self.destroy_dialog(self.dialogs[name])
self.browser.reset_rows()
else:
dialogs.Dialog('there was a problem')
def src_profile_selected(self, button):
row = get_single_row(self.dialogs['copy'], 'profile')
def show_packages(self, button, data):
PackagesWindow(self.conn, data)
def show_traits(self, button, data):
TraitsWindow(self.conn, data)
def show_traitgen(self, button, data):
TraitGenWin(self.conn, data)
class Repository(HasNameType):
def __init__(self, conn, name, type):
self.conn = conn
self.manager = RepositoryManager(self.conn)
self.sources = StatementCursor(self.conn, 'Sources')
self.sources.set_table('sources')
self.release = ReleaseCursor(self.conn)
self._section_ = PackageListCursor(self.conn)
self.set_source(name, type)
def set_source(self, name, type):
HasNameType.set_source(self, name, type)
self.release.set_source(name, type)
self._section_.set_source(name, type)
def update_release_file(self, release_file, update=False):
c = self.current
current_files = [x.path for x in self.release.select(clause=c.clause())]
source = self.manager.make_source(c.name, c.type)
r = Release((release_file, source))
for sum in r.sums.values():
row = dict(name=c.name, type=c.type, md5sum=sum.md5sum,
size=sum.size, path=sum.name)
if sum.name not in current_files:
self.release.insert(data=row)
else:
clause = c.clause() & Eq('path', sum.name)
self.release.update(data=row, clause=clause)
def insert_section_data(self, section):
c = self.current
print 'in insert_section_data current is', c
self._section_.set_section(section)
self._section_.delete()
parsed = self.manager.parse_section(c.name, c.type, section)
if c.type == 'deb':
self.insert_packages(parsed)
elif c.type == 'deb-src':
self.insert_sources(parsed)
else:
raise Error, 'bad source type'
def get_remote(self):
current = self.current
return self.make_repos_source(current.name, current.type, remote=True)
def insert_full_parse(self, section):
c = self.current
listfile = self.manager.listfile(c.name, c.type, section)
if not isfile(listfile):
raise NoFileError, 'file not there'
table = fullparse_tablename(c.name, c.type, section)
fptable = FullParseCursor(self.conn, table)
for package, data in full_parse(listfile).items():
fptable.set_package(package)
fptable.update(data)
def insert_packages(self, parsed):
for package, data in parsed.items():
insert_data = {}.fromkeys(package_columns)
for field in package_columns:
try:
insert_data[field] = data[field]
except KeyError:
if field == 'installedsize':
insert_data[field] = data['installed-size']
else:
raise KeyError, 'bad key %s' % field
self._section_.insert(data=insert_data)
def insert_sources(self, parsed):
for package, (dir, files) in parsed.items():
data = dict(package=package, directory=dir)
for afile in files:
data.update(dict(zip(['md5sum', 'size', 'filename'], afile)))
self._section_.insert(data=data)
class RelationalBrowser(ListNoteBook, HasDialogs):
def __init__(self, conn, maintable, reltable, pkey, fields):
self.menu = make_menu(['insert', 'update', 'done'], self.pkey_command)
ListNoteBook.__init__(self)
self.conn = conn
self.main = StatementCursor(self.conn)
self.main.set_table(maintable)
self.rel = StatementCursor(self.conn)
self.rel.set_table(reltable)
self.pkey = pkey
self._fields = fields
self.fields = [self.pkey] + self._fields
self.reset_rows()
self.dialogs = {}.fromkeys(['insert', 'update', 'delete'])
self.relmenu = make_menu(['insert', 'update', 'delete'], self.relmenu_command)
def reset_rows(self):
self.set_rows(self.main.select(order=self.pkey))
self.set_row_select(self.pkey_selected)
def pkey_selected(self, listbox, row, column, event):
value = listbox.get_selected_data()[0][0]
self.current_value = value
if value not in self.pages:
rows = self.rel.select(clause=Eq(self.pkey, value), order=self.pkey)
rtable = ScrollCList(rcmenu=self.relmenu)
rtable.set_rows(rows)
self.append_page(rtable, value)
self.set_current_page(value)
def pkey_command(self, menuitem, command):
if command == 'insert':
if self.dialogs['insert'] is None:
dialog = dialogs.Entry('insert a %s' % self.pkey, name='insert')
dialog.set_ok(self.pkey_insert_ok)
dialog.set_cancel(self.destroy_dialog)
self.dialogs['insert'] = dialog
elif command == 'update':
dialogs.Message('need to set update to cascade in db')
elif command == 'done':
value = None
try:
value = self.listbox.get_selected_data()[0][0]
except IndexError:
dialogs.Message('need to select %s first' % self.pkey)
if value is not None:
self.remove_page(value)
def pkey_insert_ok(self, *args):
dialog = self.dialogs['insert']
value = dialog.get()
print value
try:
self.main.insert(data={self.pkey : value})
inserted = True
except OperationalError:
dialogs.Message('bad query\n%s is not allowed' % value)
if inserted:
self.destroy_dialog(dialog)
self.reset_rows()
def relmenu_command(self, menuitem, command):
print command
if command in ['insert', 'update', 'delete']:
if self.dialogs[command] is None:
clause = Eq(self.pkey, self.current_value)
try:
row = self.rel.select(clause=clause)[0]
except IndexError:
row = dict.fromkeys(self.fields)
row[self.pkey] = self.current_value
if command in ['insert', 'delete']:
fields = self.fields
clause = None
else:
fields = self._fields
clause = Eq(self.pkey, self.current_value)
make_record_dialog(self, command, row,
self.relmenu_command_selected,
self.pkey, fields, {command:command})
print self.dialogs.items()
def relmenu_command_selected(self, button, *data):
command = button.get_name()
dialog = self.dialogs[command]
items = dialog.items()
if command == 'insert':
self.rel.insert(data=dict(items))
elif command == 'delete':
print 'delete delete delete delete'
clause = SimpleClause(items, '=', 'and')
dialogs.Message(self.rel.stmt.delete(clause=clause))
if False:
dialog = self.dialogs['insert']
print dialog
items = dialog.items()
print items
self.rel.insert(data=dict(items))
self.destroy_dialog(dialog)
self.reset_rows()
def Table_cursor(conn, table):
cursor = StatementCursor(conn, table)
cursor.set_table(table)
return cursor
class Repository(HasNameType):
def __init__(self, conn, name, type):
self.conn = conn
self.manager = RepositoryManager(self.conn)
self.sources = StatementCursor(self.conn, 'Sources')
self.sources.set_table('sources')
self.release = ReleaseCursor(self.conn)
self._section_ = PackageListCursor(self.conn)
self.set_source(name, type)
def set_source(self, name, type):
HasNameType.set_source(self, name, type)
self.release.set_source(name, type)
self._section_.set_source(name, type)
def update_release_file(self, release_file, update=False):
c = self.current
current_files = [
x.path for x in self.release.select(clause=c.clause())
]
source = self.manager.make_source(c.name, c.type)
r = Release((release_file, source))
for sum in r.sums.values():
row = dict(name=c.name,
type=c.type,
md5sum=sum.md5sum,
size=sum.size,
path=sum.name)
if sum.name not in current_files:
self.release.insert(data=row)
else:
clause = c.clause() & Eq('path', sum.name)
self.release.update(data=row, clause=clause)
def insert_section_data(self, section):
c = self.current
print 'in insert_section_data current is', c
self._section_.set_section(section)
self._section_.delete()
parsed = self.manager.parse_section(c.name, c.type, section)
if c.type == 'deb':
self.insert_packages(parsed)
elif c.type == 'deb-src':
self.insert_sources(parsed)
else:
raise Error, 'bad source type'
def get_remote(self):
current = self.current
return self.make_repos_source(current.name, current.type, remote=True)
def insert_full_parse(self, section):
c = self.current
listfile = self.manager.listfile(c.name, c.type, section)
if not isfile(listfile):
raise NoFileError, 'file not there'
table = fullparse_tablename(c.name, c.type, section)
fptable = FullParseCursor(self.conn, table)
for package, data in full_parse(listfile).items():
fptable.set_package(package)
fptable.update(data)
def insert_packages(self, parsed):
for package, data in parsed.items():
insert_data = {}.fromkeys(package_columns)
for field in package_columns:
try:
insert_data[field] = data[field]
except KeyError:
if field == 'installedsize':
insert_data[field] = data['installed-size']
else:
raise KeyError, 'bad key %s' % field
self._section_.insert(data=insert_data)
def insert_sources(self, parsed):
for package, (dir, files) in parsed.items():
data = dict(package=package, directory=dir)
for afile in files:
data.update(dict(zip(['md5sum', 'size', 'filename'], afile)))
self._section_.insert(data=data)
class PaellaProcessor(object):
def __init__(self, conn):
object.__init__(self)
self.conn = conn
self.__set_cursors__()
self.main_path = None
def parse_xml(self, filename):
self.dbdata = PaellaParser(filename)
self.main_path = dirname(filename)
def start_schema(self):
start_schema(self.conn)
self._sync_suites()
def _sync_suites(self):
self.main.set_table('suites')
current_suites = [row.suite for row in self.main.select()]
for suite in self.dbdata.suites:
if suite.name not in current_suites:
self.main.insert(data=suite)
make_suite(self.main, suite.name)
insert_packages(self.main, suite.name, quick=False)
else:
self.main.update(data=suite)
def insert_families(self):
path = join(self.main_path, 'families')
print 'path is in insert_families', path
self.family.import_families(path)
def insert_profiles(self):
path = join(self.main_path, 'profiles')
print 'path is in insert_profiles', path
xmlfiles = [
join(path, x) for x in os.listdir(path) if x[-4:] == '.xml'
]
profiles = PaellaProfiles(self.conn)
for xmlfile in xmlfiles:
xml = parse_file(xmlfile)
elements = xml.getElementsByTagName('profile')
if len(elements) != 1:
raise Error, 'bad profile number %s' % len(elements)
element = elements[0]
parsed = ProfileParser(element)
profiles.insert_profile(parsed)
def insert_profile(self, profile):
idata = {'profile': profile.name, 'suite': profile.suite}
self.main.insert(table='profiles', data=idata)
idata = {'profile': profile.name, 'trait': None, 'ord': 0}
for trait, ord in profile.traits:
print trait, ord
idata['trait'] = trait
idata['ord'] = ord #str(ord)
self.main.insert(table='profile_trait', data=idata)
idata = {
'profile': profile.name,
'trait': None,
'name': None,
'value': None
}
for trait, name, value in profile.vars:
idata['trait'] = trait
idata['name'] = name
idata['value'] = value
self.main.insert(table='profile_variables', data=idata)
def insert_traits(self, suite):
self.__set_suite_cursors__(suite)
traits = [trait for trait in self.dbdata.get_traits(suite)]
self._insert_traits_(traits, suite)
def _clear_traits(self, suite):
self.__set_suite_cursors__(suite)
self.traitparent.cmd.delete()
self.traitpackage.cmd.delete()
self.main.delete(table=ujoin(suite, 'variables'))
self.traits.delete()
def _insert_traits_(self, traits, suite):
while len(traits):
trait = traits[0]
print 'inserting %s' % trait, len(traits)
try:
self._insert_trait_(trait, suite)
except UnbornError:
traits.append(trait)
del traits[0]
def _insert_trait_(self, trait, suite):
traitdb = Trait(self.conn, suite)
#path = join(self.main_path, suite, trait + '.tar')
path = join(self.main_path, suite, trait)
traitdb.insert_trait(path, suite)
def __set_cursors__(self):
self.main = StatementCursor(self.conn, 'main_paella_cursor')
self.all_traits = StatementCursor(self.conn, 'all_traits')
self.all_traits.set_table('traits')
def __set_suite_cursors__(self, suite):
self.traits = StatementCursor(self.conn, 'traits')
self.traits.set_table(ujoin(suite, 'traits'))
self.traitparent = TraitParent(self.conn, suite)
self.traitpackage = TraitPackage(self.conn, suite)
self.traittemplate = TraitTemplate(self.conn, suite)
self.traitdebconf = TraitDebconf(self.conn, suite)
self.family = Family(self.conn)
def create(self, filename):
self.parse_xml(filename)
self.start_schema()
for suite in self.dbdata.suites:
self.insert_traits(suite.name)
self.insert_families()
self.insert_profiles()
class RepositoryManager(object):
def __init__(self, conn):
self.conn = conn
self.main = StatementCursor(self.conn, 'RepositoryMain')
self.repos = StatementCursor(self.conn, 'Repository')
self.repos.set_table('repository')
self.sources = StatementCursor(self.conn, 'Sources')
self.sources.set_table('sources')
self.release = ReleaseCursor(self.conn)
self.repsections = StatementCursor(self.conn, 'repos_section')
self.repsections.set_table('repos_section')
self.__init_db__()
def __init_db__(self):
if not len(self.main.tables()):
map(self.main.create_table, primary_tables())
def drop_source(self, name, type):
nameclause = Eq('name', name)
clause = nameclause & Eq('type', type)
for section in self.get_sections(name):
self.main.drop(list_tablename(name, type, section))
self.sources.delete(clause=clause)
sources = self.sources.select(clause=clause)
if not len(sources):
self.repsections.delete(clause=nameclause)
self.repos.delete(clause=nameclause)
def add_source(self, name, source):
source = make_source(source)
if name not in [x.name for x in self.repos.select()]:
self.repos.insert(data=dict(name=name))
clause = Eq('name', name) & Eq('type', source.type)
count = int(
self.sources.select(fields=['count(name)'], clause=clause)[0][0])
if count == 0:
if islocaluri(source.uri):
data = dict(name=name,
type=source.type,
uri=source.uri,
suite=source.suite)
self.sources.insert(data=data)
current_sections = self.get_sections(name)
sdata = dict(name=name, section=None)
for section in source.sections:
if section not in current_sections:
sdata['section'] = section
self.repsections.insert(data=sdata)
fullparse = FullParseTable(name, source.type, section)
if fullparse.name not in self.main.tables():
self.main.create_table(fullparse)
listtable = ListTable(name, source.type, section)
if listtable.name not in self.main.tables():
self.main.create_table(listtable)
else:
raise Error, 'local uris first'
else:
if not islocaluri(source.uri):
data = dict(remote=source.uri)
self.sources.update(data=data, clause=clause)
else:
raise ExistsError, 'already there'
def get_sections(self, name):
clause = Eq('name', name)
return [
x.section for x in self.repsections.iselect(fields=['section'],
clause=clause)
]
def make_source_line(self, name, type, remote=False):
repsrc = self.make_source(name, type, remote)
return str(repsrc)
def make_source(self, name, type, remote=False):
clause = Eq('name', name) & Eq('type', type)
source = self.sources.select_row(clause=clause)
repsrc = RepositorySource()
repsrc.type = source.type
if remote:
repsrc.uri = source.remote
else:
repsrc.uri = source.uri
repsrc.suite = source.suite
repsrc.sections = self.get_sections(name)
repsrc.set_path()
return repsrc
def listfile(self, name, type, section=None):
source = self.make_source(name, type)
release = Release(source)
print 'Need to pull from database!!!'
if source.has_release():
return join(source.distpath, release.path(section))
else:
return join(source.distpath, source.listfile())
def get_remote(self, name, type, remote=True):
return self.make_source(name, type, remote=True)
def parse_section(self, name, type, section=None):
listfile = self.listfile(name, type, section)
debug(listfile)
if not isfile(listfile):
raise NoFileError, 'file not there'
if type == 'deb':
return full_parse(listfile)
elif type == 'deb-src':
return parse_sources(listfile)
else:
raise Error, 'bad source type'
def add_repository(self, name):
self.repos.insert(data=dict(name=name))
class ProfileBrowser(ListNoteBook, HasDialogs):
def __init__(self, conn, suites, name='ProfileBrowser'):
self.menu = self.__make_mainmenu_(suites)
ListNoteBook.__init__(self, name=name)
self.conn = conn
self.profiles = Profile(self.conn)
self.profiletrait = ProfileTrait(self.conn)
self.family = Family(self.conn)
self.pfamily = StatementCursor(self.conn)
self.pfamily.set_table('profile_family')
self.trait_menu = make_menu(['drop', 'order'], self.trait_command)
self.pdata_menu = make_menu(['edit', 'drop'], self.variable_command)
self.family_menu = make_menu(['drop'], self.family_command)
self.reset_rows()
self.append_page(ScrollCList(rcmenu=self.trait_menu), 'traits')
self.append_page(ScrollCList(rcmenu=self.pdata_menu), 'variables')
self.append_page(ScrollCList(rcmenu=self.family_menu), 'families')
self.dialogs = {}.fromkeys(['order'])
def __make_mainmenu_(self, suites):
suite_commands = ['change to %s' %suite for suite in suites]
profile_commands = ['drop', 'set defaults', 'append defaults']
commands = suite_commands + profile_commands
return make_menu(commands, self.profile_command)
def reset_rows(self):
self.set_rows(self.profiles.select(fields=['profile', 'suite'], order='profile'))
self.set_row_select(self.profile_selected)
def profile_selected(self, listbox, row, column, event):
row = listbox.get_selected_data()[0]
self.current = row
self.select_profile(self.current.profile)
def select_profile(self, profile):
self.variables = ProfileEnvironment(self.conn, profile)
self.profiletrait.set_profile(profile)
self.__set_pages(profile)
def __set_pages(self, profile):
pages = dict(self.pages)
#set traits for profile
pages['traits'].set_rows(self.profiletrait.trait_rows())
pages['traits'].set_select_mode('multi')
clause = Eq('profile', self.current.profile)
cursor = self.variables.env.cursor
pages['variables'].set_rows(cursor.select(clause=clause), ['trait'])
pages['variables'].set_select_mode('multi')
pfrows = self.pfamily.select(fields=['family'], clause=clause)
pages['families'].set_rows(pfrows)
pages['families'].set_select_mode('multi')
self.__set_droptargets__(pages)
def __set_droptargets__(self, pages):
set_receive_targets(pages['traits'].listbox,
self.drop_trait, TARGETS.get('trait', self.current.suite))
set_receive_targets(pages['families'].listbox,
self.drop_families, FTargets.get('family', 'flavor'))
def trait_command(self, menuitem, action):
traits = self._get_listbox('traits', 'trait')
if action == 'drop':
clause = In('trait', traits) & Eq('profile', self.current.profile)
self.profiletrait.cmd.delete(clause=clause)
self.__set_pages(self.current.profile)
elif action == 'order':
if not self.dialogs['order']:
self.dialogs['order'] = dialogs.Entry('enter order', name='order')
self.dialogs['order'].set_ok(self.set_order)
self.dialogs['order'].set_cancel(self.destroy_dialog)
def variable_command(self, menuitem, action):
rows = self.pages['variables'].get_selected_data()
cursor = self.variables.env.cursor
if action == 'drop':
for row in rows:
clause = Eq('profile', self.current.profile) & Eq('trait', row.trait)
clause &= Eq('name', row.name)
cursor.delete(clause=clause)
elif action == 'edit':
self.edit_profilevars()
def family_command(self, menuitem, action):
print action
families = [x[0] for x in self.pages['families'].get_selected_data()]
if action == 'drop':
clause = Eq('profile', self.current.profile) & In('family', families)
self.pfamily.delete(clause=clause)
def edit_profilevars(self):
config = ProfileVariablesConfig(self.conn, self.current.profile)
newconfig = config.edit()
config.update(newconfig)
self.select_profile(self.current.profile)
def set_order(self, button):
dialog = self.dialogs['order']
ord = dialog.get()
rows = self.pages['traits'].get_selected_data()
pclause = Eq('profile', self.current.profile)
for row in rows:
clause = pclause & Eq('trait', row.trait)
self.profiletrait.update(data=dict(ord=ord), clause=clause)
def drop_trait(self, listbox, context, x, y, selection,
targettype, time):
traits = keysplitter(selection)
self.profiletrait.insert_traits(traits)
self.__set_pages(self.current.profile)
def drop_families(self, listbox, context, x, y, selection,
targettype, time):
families = keysplitter(selection)
clause = Eq('profile', self.current.profile)
data = dict(profile=self.current.profile)
current = [x.family for x in self.pfamily.select(clause=clause)]
for f in families:
if f not in current:
data['family'] = f
self.pfamily.insert(data=data)
self.__set_pages(self.current.profile)
def _get_listbox(self, page, field):
pages = dict(self.pages)
return [row[field] for row in pages[page].listbox.get_selected_data()]
def profile_command(self, menu, command):
if command[:10] == 'change to ':
self.change_suite(command[10:])
elif command == 'drop':
self.profiletrait.drop_profile(self.current.profile)
self.profiles.drop_profile(self.current.profile)
self.current = None
self.reset_rows()
elif command == 'set defaults':
self.variables.set_defaults()
elif command == 'append defaults':
self.variables.append_defaults()
else:
raise Error, 'bad command %s' %command
def change_suite(self, suite):
clause = Eq('profile', self.current.profile)
self.profiles.update(data={'suite' : suite}, clause=clause)
print 'changing suite to ', suite
self.current_suite = suite
self.reset_rows()
class ProfileBrowser(ListNoteBook, HasDialogs):
def __init__(self, conn, suites, name='ProfileBrowser'):
self.menu = self.__make_mainmenu_(suites)
ListNoteBook.__init__(self, name=name)
self.conn = conn
self.profiles = Profile(self.conn)
self.profiletrait = ProfileTrait(self.conn)
self.family = Family(self.conn)
self.pfamily = StatementCursor(self.conn)
self.pfamily.set_table('profile_family')
self.trait_menu = make_menu(['drop', 'order'], self.trait_command)
self.pdata_menu = make_menu(['edit', 'drop'], self.variable_command)
self.family_menu = make_menu(['drop'], self.family_command)
self.reset_rows()
self.append_page(ScrollCList(rcmenu=self.trait_menu), 'traits')
self.append_page(ScrollCList(rcmenu=self.pdata_menu), 'variables')
self.append_page(ScrollCList(rcmenu=self.family_menu), 'families')
self.dialogs = {}.fromkeys(['order'])
def __make_mainmenu_(self, suites):
suite_commands = ['change to %s' % suite for suite in suites]
profile_commands = ['drop', 'set defaults', 'append defaults']
commands = suite_commands + profile_commands
return make_menu(commands, self.profile_command)
def reset_rows(self):
self.set_rows(
self.profiles.select(fields=['profile', 'suite'], order='profile'))
self.set_row_select(self.profile_selected)
def profile_selected(self, listbox, row, column, event):
row = listbox.get_selected_data()[0]
self.current = row
self.select_profile(self.current.profile)
def select_profile(self, profile):
self.variables = ProfileEnvironment(self.conn, profile)
self.profiletrait.set_profile(profile)
self.__set_pages(profile)
def __set_pages(self, profile):
pages = dict(self.pages)
#set traits for profile
pages['traits'].set_rows(self.profiletrait.trait_rows())
pages['traits'].set_select_mode('multi')
clause = Eq('profile', self.current.profile)
cursor = self.variables.env.cursor
pages['variables'].set_rows(cursor.select(clause=clause), ['trait'])
pages['variables'].set_select_mode('multi')
pfrows = self.pfamily.select(fields=['family'], clause=clause)
pages['families'].set_rows(pfrows)
pages['families'].set_select_mode('multi')
self.__set_droptargets__(pages)
def __set_droptargets__(self, pages):
set_receive_targets(pages['traits'].listbox, self.drop_trait,
TARGETS.get('trait', self.current.suite))
set_receive_targets(pages['families'].listbox, self.drop_families,
FTargets.get('family', 'flavor'))
def trait_command(self, menuitem, action):
traits = self._get_listbox('traits', 'trait')
if action == 'drop':
clause = In('trait', traits) & Eq('profile', self.current.profile)
self.profiletrait.cmd.delete(clause=clause)
self.__set_pages(self.current.profile)
elif action == 'order':
if not self.dialogs['order']:
self.dialogs['order'] = dialogs.Entry('enter order',
name='order')
self.dialogs['order'].set_ok(self.set_order)
self.dialogs['order'].set_cancel(self.destroy_dialog)
def variable_command(self, menuitem, action):
rows = self.pages['variables'].get_selected_data()
cursor = self.variables.env.cursor
if action == 'drop':
for row in rows:
clause = Eq('profile', self.current.profile) & Eq(
'trait', row.trait)
clause &= Eq('name', row.name)
cursor.delete(clause=clause)
elif action == 'edit':
self.edit_profilevars()
def family_command(self, menuitem, action):
print action
families = [x[0] for x in self.pages['families'].get_selected_data()]
if action == 'drop':
clause = Eq('profile', self.current.profile) & In(
'family', families)
self.pfamily.delete(clause=clause)
def edit_profilevars(self):
config = ProfileVariablesConfig(self.conn, self.current.profile)
newconfig = config.edit()
config.update(newconfig)
self.select_profile(self.current.profile)
def set_order(self, button):
dialog = self.dialogs['order']
ord = dialog.get()
rows = self.pages['traits'].get_selected_data()
pclause = Eq('profile', self.current.profile)
for row in rows:
clause = pclause & Eq('trait', row.trait)
self.profiletrait.update(data=dict(ord=ord), clause=clause)
def drop_trait(self, listbox, context, x, y, selection, targettype, time):
traits = keysplitter(selection)
self.profiletrait.insert_traits(traits)
self.__set_pages(self.current.profile)
def drop_families(self, listbox, context, x, y, selection, targettype,
time):
families = keysplitter(selection)
clause = Eq('profile', self.current.profile)
data = dict(profile=self.current.profile)
current = [x.family for x in self.pfamily.select(clause=clause)]
for f in families:
if f not in current:
data['family'] = f
self.pfamily.insert(data=data)
self.__set_pages(self.current.profile)
def _get_listbox(self, page, field):
pages = dict(self.pages)
return [row[field] for row in pages[page].listbox.get_selected_data()]
def profile_command(self, menu, command):
if command[:10] == 'change to ':
self.change_suite(command[10:])
elif command == 'drop':
self.profiletrait.drop_profile(self.current.profile)
self.profiles.drop_profile(self.current.profile)
self.current = None
self.reset_rows()
elif command == 'set defaults':
self.variables.set_defaults()
elif command == 'append defaults':
self.variables.append_defaults()
else:
raise Error, 'bad command %s' % command
def change_suite(self, suite):
clause = Eq('profile', self.current.profile)
self.profiles.update(data={'suite': suite}, clause=clause)
print 'changing suite to ', suite
self.current_suite = suite
self.reset_rows()
class PaellaProcessor(object):
def __init__(self, conn):
object.__init__(self)
self.conn = conn
self.__set_cursors__()
self.main_path = None
def parse_xml(self, filename):
self.dbdata = PaellaParser(filename)
self.main_path = dirname(filename)
def start_schema(self):
start_schema(self.conn)
self._sync_suites()
def _sync_suites(self):
self.main.set_table('suites')
current_suites = [row.suite for row in self.main.select()]
for suite in self.dbdata.suites:
if suite.name not in current_suites:
self.main.insert(data=suite)
make_suite(self.main, suite.name)
insert_packages(self.main, suite.name)
else:
self.main.update(data=suite)
def insert_profiles(self):
path = join(self.main_path, 'profiles')
print 'path is in insert_profiles', path
xmlfiles = [join(path, x) for x in os.listdir(path) if x[-4:] == '.xml']
profiles = PaellaProfiles(self.conn)
for xmlfile in xmlfiles:
xml = parse_file(xmlfile)
elements = xml.getElementsByTagName('profile')
if len(elements) != 1:
raise Error, 'bad profile number %s' % len(elements)
element = elements[0]
parsed = ProfileParser(element)
profiles.insert_profile(parsed)
def insert_profile(self, profile):
idata = {'profile' : profile.name,
'suite' : profile.suite}
self.main.insert(table='profiles', data=idata)
idata = {'profile' : profile.name,
'trait' : None,
'ord' : 0}
for trait, ord in profile.traits:
print trait, ord
idata['trait'] = trait
idata['ord'] = ord #str(ord)
self.main.insert(table='profile_trait', data=idata)
idata = {'profile' : profile.name,
'trait' : None,
'name' : None,
'value': None}
for trait, name, value in profile.vars:
idata['trait'] = trait
idata['name'] = name
idata['value'] = value
self.main.insert(table='profile_variables', data=idata)
def insert_traits(self, suite):
self.__set_suite_cursors__(suite)
traits = [trait for trait in self.dbdata.get_traits(suite)]
self._insert_traits_(traits, suite)
def _clear_traits(self, suite):
self.__set_suite_cursors__(suite)
self.traitparent.cmd.delete()
self.traitpackage.cmd.delete()
self.main.delete(table=ujoin(suite, 'variables'))
self.traits.delete()
def _insert_traits_(self, traits, suite):
while len(traits):
trait = traits[0]
print 'inserting %s' %trait, len(traits)
try:
self._insert_trait_(trait, suite)
except UnbornError:
traits.append(trait)
del traits[0]
def _insert_trait_(self, trait, suite):
traitdb = Trait(self.conn, suite)
path = join(self.main_path, suite, trait + '.tar')
traitdb.insert_trait(path, suite)
def __set_cursors__(self):
self.main = StatementCursor(self.conn, 'main_paella_cursor')
self.all_traits = StatementCursor(self.conn, 'all_traits')
self.all_traits.set_table('traits')
def __set_suite_cursors__(self, suite):
self.traits = StatementCursor(self.conn, 'traits')
self.traits.set_table(ujoin(suite, 'traits'))
self.traitparent = TraitParent(self.conn, suite)
self.traitpackage = TraitPackage(self.conn, suite)
self.traittemplate = TraitTemplate(self.conn, suite)
self.traitdebconf = TraitDebconf(self.conn, suite)
def create(self, filename):
for table in self.main.tables():
self.main.execute('drop table %s' %table)
self.parse_xml(filename)
self.start_schema()
for suite in self.dbdata.suites:
self.insert_traits(suite.name)
self.insert_profiles()
class TemplateManager(MenuWindow):
def __init__(self, conn, suite):
MenuWindow.__init__(self)
self.set_title('%s template manager' % suite)
self.conn = conn
self.suite = suite
self.main = StatementCursor(self.conn)
self.browser = TraitTemplateBrowser(self.conn, suite)
self.vbox.add(self.browser)
self.add_menu(['all', 'profile'], 'selection',
self.set_trait_selection)
self.add_menu(TEMPL_CMDS, 'template', self.template_command)
tc = TRAIT_TEMPL_CMDS
self.add_menu(tc, 'trait', self.trait_command)
self.set_size_request(600, 400)
self.dialogs = {}.fromkeys(['select trait', 'select profile'])
self.browser.set_suite(suite)
def template_command(self, menuitem, command):
if self.browser.extracted is None and command in [
'new', 'diff', 'load'
]:
dialogs.Message('packages not yet extracted')
else:
self.browser.template_command(command)
def trait_command(self, menuitem, command):
tc = TRAIT_TEMPL_CMDS
if command == tc[0]:
if self.dialogs[command] is None:
self._trait_select_dialog(command)
elif command == tc[1]:
#self._extract_packages()
pass
elif command == tc[2]:
TraitGenWin(self.conn, self.suite)
def _trait_select_dialog(self, name):
dialog = dialogs.CList(name, name=name)
self.main.set_table(ujoin(self.browser.suite, 'traits'))
traits = self.main.select(fields=['trait'])
dialog.set_rows(traits)
dialog.set_ok(self.select_trait)
dialog.set_cancel(self.destroy_dialog)
self.dialogs[name] = dialog
def select_trait(self, *args):
trait = self.dialogs['select trait'].get_selected_data()[0].trait
self.destroy_dialog(self.dialogs['select trait'])
self.set_trait(trait)
self.set_title('suite: %s trait:%s' % (self.browser.suite, trait))
def set_trait(self, trait):
self.browser.extracted = None
self.browser.select_trait(trait)
def templates(self):
return [x.template for x in self.browser.traittemplate.templates()]
def ask_file_dialog(self, menuitem, name):
if name in ['open', 'save']:
filesel = FileSelection(title=name)
filesel.cancel_button.connect('clicked',
lambda x: filesel.destroy())
filesel.show()
if name == 'save':
if not has_extension(self.filename, 'template'):
path = self._tmpl_path_()
else:
path = pjoin(self.template_path, self.filename)
makepaths(dirname(path))
elif name == 'open':
self.filename = ''
path = pjoin(self.tmp_path, self.filename)
print 'open', path
elif name == 'edit' and self.filename:
path = self._tmpl_path_()
self._fill_from_path(self._tmpl_path_())
if name in ['open', 'save']:
filesel.set_filename(path)
filesel.ok_button.connect('clicked', self.ok_file, filesel)
filesel.set_data('action', name)
def set_trait_selection(self, menuitem, command):
print menuitem, command
if command == 'all':
self.browser.trait_selection = '_all_traits_'
self.browser.reset_rows()
else:
dialog = dialogs.CList('hi there', name='select profile')
profiles = self.main.select(fields=['profile'],
table='profiles',
clause=Eq('suite', self.suite))
dialog.set_rows(profiles)
dialog.set_ok(self.profile_dialog_selected)
dialog.set_cancel(self.destroy_dialog)
self.dialogs['select profile'] = dialog
def profile_dialog_selected(self, *args):
profile = self.dialogs['select profile'].get_selected_data()[0][0]
self.destroy_dialog(self.dialogs['select profile'])
self.browser.trait_selection = profile
self.browser.reset_rows()
class VariablesConfig(RawConfigParser):
def __init__(self,
conn,
table,
section,
mainfield=None,
mainvalue=None,
option='name',
value='value'):
self.conn = conn
self.cursor = StatementCursor(self.conn)
self.cursor.set_table(table)
self._secfield = section
bothnone = mainfield is None and mainvalue is None
bothset = mainfield and mainvalue
if not bothnone and not bothset:
raise Error, 'both mainfield and mainvalue need to be set/unset'
self._mainclause = None
if bothset:
self._mainclause = Eq(mainfield, mainvalue)
self._fields = [self._secfield, option, value]
RawConfigParser.__init__(self)
for row in self.cursor.select(fields=self._fields,
clause=self._mainclause):
if row[0] not in self.sections():
self.add_section(row[0])
self.set(*row)
def write(self, cfile):
sections = self.sections()
sections.sort()
for section in sections:
cfile.write('[%s]\n' % section)
keys = self.options(section)
keys.sort()
for k in keys:
if k != '__name__':
v = str(self.get(section, k)).replace('\n', '\n\t')
cfile.write('%s:\t%s\n' % (k, v))
cfile.write('\n')
def edit(self):
tmp, path = tempfile.mkstemp('variables', 'config')
tmp = file(path, 'w')
self.write(tmp)
tmp.close()
os.system('$EDITOR %s' % path)
tmp = file(path, 'r')
newconfig = RawConfigParser()
newconfig.readfp(tmp)
tmp.close()
os.remove(path)
return newconfig
def diff(self, other):
ltmp, lpath = tempfile.mkstemp('variables', 'config')
ltmp = file(lpath, 'w')
self.write(ltmp)
ltmp.close()
rtmp, rpath = tempfile.mkstemp('variables', 'config')
rtmp = file(rpath, 'w')
other.write(rtmp)
rtmp.close()
os.system('xxdiff %s %s' % (lpath, rpath))
ltmp, rtmp = file(lpath, 'r'), file(rpath, 'r')
lcfg, rcfg = RawConfigParser(), RawConfigParser()
lcfg.readfp(ltmp)
rcfg.readfp(rtmp)
ltmp.close()
rtmp.close()
self.update(lcfg)
other.update(rcfg)
def update(self, newconfig):
removed = [x for x in self.sections() if x not in newconfig.sections()]
for section in removed:
print 'removing', section
sclause = Eq(self._secfield, section)
if self._mainclause:
sclause &= self._mainclause
self.cursor.delete(clause=sclause)
for section in newconfig.sections():
print section
sclause = Eq(self._secfield, section)
if self._mainclause:
sclause = self._mainclause & Eq(self._secfield, section)
if not self.has_section(section):
for k, v in newconfig.items(section):
idata = dict(zip(self._fields, [section, k, v]))
if self._mainclause:
idata[self._mainclause.left] = self._mainclause.right
print idata
self.cursor.insert(data=idata)
else:
for name, value in newconfig.items(section):
nclause = sclause & Eq(self._fields[1], name)
#print 'nclause', nclause
#print 'value', self.get(section, name)
if self.has_option(section, name):
if value != self.get(section, name):
#print 'updating'
self.cursor.update(data={self._fields[2]: value},
clause=nclause)
else:
idata = dict(zip(self._fields, [section, name, value]))
if self._mainclause:
idata[
self._mainclause.left] = self._mainclause.right
self.cursor.insert(data=idata)
if self.has_section(section):
for name, value in self.items(section):
if not newconfig.has_option(section, name):
clause = sclause & Eq(self._fields[1], name)
#print 'dclause', clause
self.cursor.delete(clause=clause)
def Table_cursor(conn, table):
cursor = StatementCursor(conn, table)
cursor.set_table(table)
return cursor
class Profile(StatementCursor):
def __init__(self, conn):
StatementCursor.__init__(self, conn)
self.conn = conn
self.set_table('profiles')
self._traits = ProfileTrait(conn)
self._env = ProfileEnvironment(conn)
self._pfam = StatementCursor(conn)
self._pfam.set_table('profile_family')
self._fam = Family(conn)
def drop_profile(self, profile):
self.delete(clause=Eq('profile', profile))
def set_profile(self, profile):
self.clause = Eq('profile', profile)
self.current = self.select_row(clause=self.clause)
self._traits.set_profile(profile)
self._env.set_profile(profile)
def get_profile_data(self):
return self._env.ProfileData()
def get_family_data(self):
families = self.get_families()
return self._fam.FamilyData(families)
def make_traitlist(self, log=None):
tp = TraitParent(self.conn, self.current.suite)
listed = [x.trait for x in self._traits.trait_rows()]
all = list(tp.get_traitset(listed))
setfun = tp.set_trait
parfun = tp.parents
return make_deplist(listed, all, setfun, parfun, log)
def family_rows(self, profile=None):
if profile is None:
profile = self.current.profile
return self._pfam.select(clause=Eq('profile', profile), order='family')
def get_families(self, profile=None):
return [r.family for r in self.family_rows(profile)]
def get_trait_rows(self):
return self._traits.trait_rows()
def append_family(self, family):
if family not in self.get_families():
self._pfam.insert(
data=dict(profile=self.current.profile, family=family))
def append_trait(self, trait, ord):
self._traits.insert_trait(trait, ord)
def set_suite(self, suite):
clause = Eq('profile', self.current.profile)
self.update(data=dict(suite=suite), clause=clause)
self.set_profile(self.current.profile)
def copy_profile(self, src, dest):
current = self.current
self.set_profile(src)
pfield = "'%s' as profile" % dest
pclause = Eq('profile', src)
pcursor = self
tcursor = self._traits.cmd
fcusor = self._pfam
vcursor = self._env.env.cursor
cursors = [pcursor, tcursor, fcusor, vcursor]
for cursor in cursors:
sel = str(
cursor.stmt.select(fields=[pfield] + cursor.fields()[1:],
clause=pclause))
cursor.execute('insert into %s (%s)' % (cursor.stmt.table, sel))
self.set_profile(current.profile)
class DiskManager(object):
def __init__(self, conn):
self.conn = conn
self.parser = PartitionParser()
self.cursor = StatementCursor(self.conn)
def _quick_partition(self, device, data):
i, o = os.popen2('sfdisk %s' % device)
i.write(data)
i.close()
def get_partition_info(self, device, parser=None):
if parser is None:
parser = self.parser
command = 'bash -c "sfdisk -d %s | grep %s"' % (device, device)
part_info = commands.getoutput(command)
return self._parse_diskconfig(device, part_info)
def _parse_diskconfig(self, device, astring):
parsed = self.parser.parseString(astring)
partitions = []
for p in parsed:
pnum = p[0].split(device)[1]
pdict = dict(partition=pnum, start=p[1], size=p[2], Id=p[3])
partitions.append(pdict)
return partitions
def _submit_diskconfig(self, diskname, device, astring):
workspace = 'partition_workspace'
self.cursor.delete(table=workspace, clause=(Eq('diskname', diskname)))
row = dict(diskname=diskname)
for partition in self._parse_diskconfig(device, astring):
print 'submitting', partition
row.update(partition)
self.cursor.insert(table=workspace, data=row)
def submit_partitions(self, diskname, device):
self.cursor.set_table('partition_workspace')
self.cursor.delete(clause=(Eq('diskname', diskname)))
row = dict(diskname=diskname)
print 'submitting', device
for partition in self.get_partition_info(device):
print 'submitting', partition
row.update(partition)
self.cursor.insert(data=row)
def approve_disk(self, diskname):
clause = Eq('diskname', diskname)
workspace = 'partition_workspace'
sql = Statement('select')
sql.table = workspace
sql.clause = clause
new_rows = sql.select(order='partition')
if diskname not in [r.diskname for r in self.cursor.select(table='disks')]:
self.cursor.insert(table='disks', data=dict(diskname=diskname))
else:
self.cursor.delete(table='partitions', clause=clause)
self.cursor.execute('insert into partitions %s' % new_rows)
def get_partitions_by_name(self, diskname):
return self.cursor.select(table='partitions',
clause=Eq('diskname', diskname),
order='partition')
def make_partition_dump(self, device, partitions):
output = '# partition table of %s\n'
output += 'unit: sectors\n'
for p in partitions:
line = '%s%s : start= %8d, size= %8d, Id=%2d' % \
(device, p.partition, p.start, p.size, p.id)
output += line + '\n'
return output
def partition_disk(self, diskname, device):
partitions = self.get_partitions_by_name(diskname)
data = self.make_partition_dump(device, partitions)
self._quick_partition(device, data)
def clear_partition_table(self, device):
command = 'dd if=/dev/zero of=%s count=1 bs=512' % device
os.system(command)
def get_traits(conn, profile):
cursor = StatementCursor(conn)
cursor.set_table('profile_trait')
cursor.set_clause([('profile', profile)])
return [r.trait for r in cursor.select()]
class TemplateManager(MenuWindow):
def __init__(self, conn, suite):
MenuWindow.__init__(self)
self.set_title('%s template manager' % suite)
self.conn = conn
self.suite = suite
self.main = StatementCursor(self.conn)
self.browser = TraitTemplateBrowser(self.conn, suite)
self.vbox.add(self.browser)
self.add_menu(['all', 'profile'], 'selection', self.set_trait_selection)
self.add_menu(TEMPL_CMDS, 'template', self.template_command)
tc = TRAIT_TEMPL_CMDS
self.add_menu(tc, 'trait', self.trait_command)
self.set_size_request(600,400)
self.dialogs = {}.fromkeys(['select trait', 'select profile'])
self.browser.set_suite(suite)
def template_command(self, menuitem, command):
if self.browser.extracted is None and command in ['new', 'diff', 'load']:
dialogs.Message('packages not yet extracted')
else:
self.browser.template_command(command)
def trait_command(self, menuitem, command):
tc = TRAIT_TEMPL_CMDS
if command == tc[0]:
if self.dialogs[command] is None:
self._trait_select_dialog(command)
elif command == tc[1]:
#self._extract_packages()
pass
elif command == tc[2]:
TraitGenWin(self.conn, self.suite)
def _trait_select_dialog(self, name):
dialog = dialogs.CList(name, name=name)
self.main.set_table(ujoin(self.browser.suite, 'traits'))
traits = self.main.select(fields=['trait'])
dialog.set_rows(traits)
dialog.set_ok(self.select_trait)
dialog.set_cancel(self.destroy_dialog)
self.dialogs[name] = dialog
def select_trait(self, *args):
trait = self.dialogs['select trait'].get_selected_data()[0].trait
self.destroy_dialog(self.dialogs['select trait'])
self.set_trait(trait)
self.set_title('suite: %s trait:%s' %(self.browser.suite, trait))
def set_trait(self, trait):
self.browser.extracted = None
self.browser.select_trait(trait)
def templates(self):
return [x.template for x in self.browser.traittemplate.templates()]
def ask_file_dialog(self, menuitem, name):
if name in ['open', 'save']:
filesel = FileSelection(title=name)
filesel.cancel_button.connect('clicked',
lambda x: filesel.destroy())
filesel.show()
if name == 'save':
if not has_extension(self.filename, 'template'):
path = self._tmpl_path_()
else:
path = pjoin(self.template_path, self.filename)
makepaths(dirname(path))
elif name =='open':
self.filename = ''
path = pjoin(self.tmp_path, self.filename)
print 'open', path
elif name == 'edit' and self.filename:
path = self._tmpl_path_()
self._fill_from_path(self._tmpl_path_())
if name in ['open', 'save']:
filesel.set_filename(path)
filesel.ok_button.connect('clicked', self.ok_file, filesel)
filesel.set_data('action', name)
def set_trait_selection(self, menuitem, command):
print menuitem, command
if command == 'all':
self.browser.trait_selection = '_all_traits_'
self.browser.reset_rows()
else:
dialog = dialogs.CList('hi there', name='select profile')
profiles = self.main.select(fields=['profile'],
table='profiles', clause=Eq('suite', self.suite))
dialog.set_rows(profiles)
dialog.set_ok(self.profile_dialog_selected)
dialog.set_cancel(self.destroy_dialog)
self.dialogs['select profile'] = dialog
def profile_dialog_selected(self, *args):
profile = self.dialogs['select profile'].get_selected_data()[0][0]
self.destroy_dialog(self.dialogs['select profile'])
self.browser.trait_selection = profile
self.browser.reset_rows()
class ProfileGenWin(CommandBoxWindow):
def __init__(self, conn, name='ProfileGenWin'):
actions = ['create', 'copy', 'export', 'import']
CommandBoxWindow.__init__(self, name=name)
self.set_title(name)
self.conn = conn
self.cmd = StatementCursor(conn, name)
self.suites = [x.suite for x in self.cmd.select(table='suites')]
self.profiles = StatementCursor(conn, 'profiles')
self.profiles.set_table('profiles')
self.menu_bar = SimpleMenuBar()
self.vbox.pack_start(self.menu_bar, 0, 0, 0)
self.dialogs = {}.fromkeys(actions)
self.add_menu(actions, 'main', self.ask_dialog)
self.add_menu(self.suites, 'traits', self.show_traits)
self.add_menu(self.suites, 'traitgen', self.show_traitgen)
self.browser = ProfileBrowser(self.conn, self.suites)
self.vbox.add(self.browser)
self.set_size_request(400, 300)
def ask_dialog(self, button, data):
if not self.dialogs[data]:
if data == 'create':
self.dialogs[data] = dialogs.Entry('create profile',
name='create')
self.dialogs[data].set_ok(self.create_profile)
elif data == 'copy':
self.dialogs[data] = dialogs.CList('copy profile', name='copy')
dialog = self.dialogs[data]
dialog.set_rows(
self.profiles.select(fields='profile', order='profile'))
dialog.set_ok(self.src_profile_selected)
elif data == 'export':
pdb = PaellaDatabase(self.conn)
profiles = pdb.profiles
self.dialogs[data].set_cancel(self.destroy_dialog)
def destroy_dialog(self, dying):
name = dying.get_name()
self.dialogs[name] = None
dying.destroy()
def create_profile(self, button):
name = button.get_name()
debug(name)
if name == 'create':
profile = self.dialogs[name].get()
if profile not in [p.profile for p in self.profiles.select()]:
self.profiles.insert(data={
'profile': profile,
'suite': 'woody'
})
self.destroy_dialog(self.dialogs[name])
self.browser.reset_rows()
else:
dialogs.Dialog('there was a problem')
def src_profile_selected(self, button):
row = get_single_row(self.dialogs['copy'], 'profile')
def show_packages(self, button, data):
PackagesWindow(self.conn, data)
def show_traits(self, button, data):
TraitsWindow(self.conn, data)
def show_traitgen(self, button, data):
TraitGenWin(self.conn, data)
def get_suite(conn, profile):
cursor = StatementCursor(conn)
cursor.set_table('profiles')
cursor.set_clause([('profile', profile)])
return [r.suite for r in cursor.select()][0]
def get_traits(conn, profile):
cursor = StatementCursor(conn)
cursor.set_table('profile_trait')
cursor.set_clause([('profile', profile)])
return [r.trait for r in cursor.select()]
class VariablesConfig(RawConfigParser):
def __init__(self, conn, table, section,
mainfield=None, mainvalue=None,
option='name', value='value'):
self.conn = conn
self.cursor = StatementCursor(self.conn)
self.cursor.set_table(table)
self._secfield = section
bothnone = mainfield is None and mainvalue is None
bothset = mainfield and mainvalue
if not bothnone and not bothset:
raise Error, 'both mainfield and mainvalue need to be set/unset'
self._mainclause = None
if bothset:
self._mainclause = Eq(mainfield, mainvalue)
self._fields = [self._secfield, option, value]
RawConfigParser.__init__(self)
for row in self.cursor.select(fields=self._fields, clause=self._mainclause):
if row[0] not in self.sections():
self.add_section(row[0])
self.set(*row)
def write(self, cfile):
sections = self.sections()
sections.sort()
for section in sections:
cfile.write('[%s]\n' % section)
keys = self.options(section)
keys.sort()
for k in keys:
if k != '__name__':
v = str(self.get(section, k)).replace('\n', '\n\t')
cfile.write('%s:\t%s\n' % (k, v))
cfile.write('\n')
def edit(self):
tmp, path = tempfile.mkstemp('variables', 'config')
tmp = file(path, 'w')
self.write(tmp)
tmp.close()
os.system('$EDITOR %s' % path)
tmp = file(path, 'r')
newconfig = RawConfigParser()
newconfig.readfp(tmp)
tmp.close()
os.remove(path)
return newconfig
def diff(self, other):
ltmp, lpath = tempfile.mkstemp('variables', 'config')
ltmp = file(lpath, 'w')
self.write(ltmp)
ltmp.close()
rtmp, rpath = tempfile.mkstemp('variables', 'config')
rtmp = file(rpath, 'w')
other.write(rtmp)
rtmp.close()
os.system('xxdiff %s %s' % (lpath, rpath))
ltmp, rtmp = file(lpath, 'r'), file(rpath, 'r')
lcfg, rcfg = RawConfigParser(), RawConfigParser()
lcfg.readfp(ltmp)
rcfg.readfp(rtmp)
ltmp.close()
rtmp.close()
self.update(lcfg)
other.update(rcfg)
def update(self, newconfig):
removed = [x for x in self.sections() if x not in newconfig.sections()]
for section in removed:
print 'removing', section
sclause = Eq(self._secfield, section)
if self._mainclause:
sclause &= self._mainclause
self.cursor.delete(clause=sclause)
for section in newconfig.sections():
print section
sclause = Eq(self._secfield, section)
if self._mainclause:
sclause = self._mainclause & Eq(self._secfield, section)
if not self.has_section(section):
for k,v in newconfig.items(section):
idata = dict(zip(self._fields, [section, k, v]))
if self._mainclause:
idata[self._mainclause.left] = self._mainclause.right
print idata
self.cursor.insert(data=idata)
else:
for name, value in newconfig.items(section):
nclause = sclause & Eq(self._fields[1], name)
#print 'nclause', nclause
#print 'value', self.get(section, name)
if self.has_option(section, name):
if value != self.get(section, name):
#print 'updating'
self.cursor.update(data={self._fields[2] : value}, clause=nclause)
else:
idata = dict(zip(self._fields, [section, name, value]))
if self._mainclause:
idata[self._mainclause.left] = self._mainclause.right
self.cursor.insert(data=idata)
if self.has_section(section):
for name, value in self.items(section):
if not newconfig.has_option(section, name):
clause = sclause & Eq(self._fields[1], name)
#print 'dclause', clause
self.cursor.delete(clause=clause)
def get_suite(conn, profile):
cursor = StatementCursor(conn)
cursor.set_table('profiles')
cursor.set_clause([('profile', profile)])
return [r.suite for r in cursor.select()][0]
class DiskManager(object):
def __init__(self, conn):
self.conn = conn
self.parser = PartitionParser()
self.cursor = StatementCursor(self.conn)
def _quick_partition(self, device, data):
i, o = os.popen2('sfdisk %s' % device)
i.write(data)
i.close()
def get_partition_info(self, device, parser=None):
if parser is None:
parser = self.parser
command = 'bash -c "sfdisk -d %s | grep %s"' % (device, device)
part_info = commands.getoutput(command)
return self._parse_diskconfig(device, part_info)
def _parse_diskconfig(self, device, astring):
parsed = self.parser.parseString(astring)
partitions = []
for p in parsed:
pnum = p[0].split(device)[1]
pdict = dict(partition=pnum, start=p[1], size=p[2], Id=p[3])
partitions.append(pdict)
return partitions
def _submit_diskconfig(self, diskname, device, astring):
workspace = 'partition_workspace'
self.cursor.delete(table=workspace, clause=(Eq('diskname', diskname)))
row = dict(diskname=diskname)
for partition in self._parse_diskconfig(device, astring):
print 'submitting', partition
row.update(partition)
self.cursor.insert(table=workspace, data=row)
def submit_partitions(self, diskname, device):
self.cursor.set_table('partition_workspace')
self.cursor.delete(clause=(Eq('diskname', diskname)))
row = dict(diskname=diskname)
print 'submitting', device
for partition in self.get_partition_info(device):
print 'submitting', partition
row.update(partition)
self.cursor.insert(data=row)
def approve_disk(self, diskname):
clause = Eq('diskname', diskname)
workspace = 'partition_workspace'
sql = Statement('select')
sql.table = workspace
sql.clause = clause
new_rows = sql.select(order='partition')
if diskname not in [
r.diskname for r in self.cursor.select(table='disks')
]:
self.cursor.insert(table='disks', data=dict(diskname=diskname))
else:
self.cursor.delete(table='partitions', clause=clause)
self.cursor.execute('insert into partitions %s' % new_rows)
def get_partitions_by_name(self, diskname):
return self.cursor.select(table='partitions',
clause=Eq('diskname', diskname),
order='partition')
def make_partition_dump(self, device, partitions):
output = '# partition table of %s\n'
output += 'unit: sectors\n'
for p in partitions:
line = '%s%s : start= %8d, size= %8d, Id=%2d' % \
(device, p.partition, p.start, p.size, p.id)
output += line + '\n'
return output
def partition_disk(self, diskname, device):
partitions = self.get_partitions_by_name(diskname)
data = self.make_partition_dump(device, partitions)
self._quick_partition(device, data)
def clear_partition_table(self, device):
command = 'dd if=/dev/zero of=%s count=1 bs=512' % device
os.system(command)
class RelationalBrowser(ListNoteBook, HasDialogs):
def __init__(self, conn, maintable, reltable, pkey, fields):
self.menu = make_menu(["insert", "update", "done"], self.pkey_command)
ListNoteBook.__init__(self)
self.conn = conn
self.main = StatementCursor(self.conn)
self.main.set_table(maintable)
self.rel = StatementCursor(self.conn)
self.rel.set_table(reltable)
self.pkey = pkey
self._fields = fields
self.fields = [self.pkey] + self._fields
self.reset_rows()
self.dialogs = {}.fromkeys(["insert", "update", "delete"])
self.relmenu = make_menu(["insert", "update", "delete"], self.relmenu_command)
def reset_rows(self):
self.set_rows(self.main.select(order=self.pkey))
self.set_row_select(self.pkey_selected)
def pkey_selected(self, listbox, row, column, event):
value = listbox.get_selected_data()[0][0]
self.current_value = value
if value not in self.pages:
rows = self.rel.select(clause=Eq(self.pkey, value), order=self.pkey)
rtable = ScrollCList(rcmenu=self.relmenu)
rtable.set_rows(rows)
self.append_page(rtable, value)
self.set_current_page(value)
def pkey_insert_ok(self, *args):
dialog = self.dialogs["insert"]
value = dialog.get()
print value
try:
self.main.insert(data={self.pkey: value})
inserted = True
except OperationalError:
dialogs.Message("bad query\n%s is not allowed" % value)
if inserted:
self.destroy_dialog(dialog)
self.reset_rows()
def relmenu_command(self, menuitem, command):
print command
if command in ["insert", "update", "delete"]:
if self.dialogs[command] is None:
clause = Eq(self.pkey, self.current_value)
try:
row = self.rel.select(clause=clause)[0]
except IndexError:
row = dict.fromkeys(self.fields)
row[self.pkey] = self.current_value
if command in ["insert", "delete"]:
fields = self.fields
clause = None
else:
fields = self._fields
clause = Eq(self.pkey, self.current_value)
make_record_dialog(
self, command, row, self.relmenu_command_selected, self.pkey, fields, {command: command}
)
print self.dialogs.items()
def relmenu_command_selected(self, button, *data):
command = button.get_name()
dialog = self.dialogs[command]
items = dialog.items()
if command == "insert":
self.rel.insert(data=dict(items))
elif command == "delete":
print "delete delete delete delete"
clause = SimpleClause(items, "=", "and")
dialogs.Message(self.rel.stmt.delete(clause=clause))
if False:
dialog = self.dialogs["insert"]
print dialog
items = dialog.items()
print items
self.rel.insert(data=dict(items))
self.destroy_dialog(dialog)
self.reset_rows()
class Profile(StatementCursor):
def __init__(self, conn):
StatementCursor.__init__(self, conn)
self.conn = conn
self.set_table('profiles')
self._traits = ProfileTrait(conn)
self._env = ProfileEnvironment(conn)
self._pfam = StatementCursor(conn)
self._pfam.set_table('profile_family')
self._fam = Family(conn)
def drop_profile(self, profile):
self.delete(clause=Eq('profile', profile))
def set_profile(self, profile):
self.clause = Eq('profile', profile)
self.current = self.select_row(clause=self.clause)
self._traits.set_profile(profile)
self._env.set_profile(profile)
def get_profile_data(self):
return self._env.ProfileData()
def get_family_data(self):
families = self.get_families()
return self._fam.FamilyData(families)
def make_traitlist(self, log=None):
tp = TraitParent(self.conn, self.current.suite)
listed = [x.trait for x in self._traits.trait_rows()]
all = list(tp.get_traitset(listed))
setfun = tp.set_trait
parfun = tp.parents
return make_deplist(listed, all, setfun, parfun, log)
def family_rows(self, profile=None):
if profile is None:
profile = self.current.profile
return self._pfam.select(clause=Eq('profile', profile), order='family')
def get_families(self, profile=None):
return [r.family for r in self.family_rows(profile)]
def get_trait_rows(self):
return self._traits.trait_rows()
def append_family(self, family):
if family not in self.get_families():
self._pfam.insert(data=dict(profile=self.current.profile, family=family))
def append_trait(self, trait, ord):
self._traits.insert_trait(trait, ord)
def set_suite(self, suite):
clause = Eq('profile', self.current.profile)
self.update(data=dict(suite=suite), clause=clause)
self.set_profile(self.current.profile)
def copy_profile(self, src, dest):
current = self.current
self.set_profile(src)
pfield = "'%s' as profile" % dest
pclause = Eq('profile', src)
pcursor = self
tcursor = self._traits.cmd
fcusor = self._pfam
vcursor = self._env.env.cursor
cursors = [ pcursor, tcursor, fcusor, vcursor]
for cursor in cursors:
sel = str(cursor.stmt.select(fields = [pfield] + cursor.fields()[1:], clause=pclause))
cursor.execute('insert into %s (%s)' % (cursor.stmt.table, sel))
self.set_profile(current.profile)
