def update_lists(self, fields, suffix):
self.lsuite = self.suite_bar.lcombo.get()
self.rsuite = self.suite_bar.rcombo.get()
self.cursor.set_fields(fields)
clause = None
ltrait = self.trait_bar.lcombo.get()
if ltrait:
clause = Eq('trait', ltrait)
table = '%s_%s' % (self.lsuite, suffix)
rows = self.cursor.select(table=table, clause=clause, order=fields)
self.view.lbox.set_rows(rows)
clause = None
rtrait = self.trait_bar.rcombo.get()
if rtrait:
clause = Eq('trait', rtrait)
table = '%s_%s' % (self.rsuite, suffix)
rows = self.cursor.select(table=table, clause=clause, order=fields)
self.view.rbox.set_rows(rows)
fields = ['trait']
self.cursor.set_fields(fields)
rows = self.cursor.select(table='%s_traits' % self.lsuite, order=fields)
ltraits = [r.trait for r in rows]
rows = self.cursor.select(table='%s_traits' % self.rsuite, order=fields)
rtraits = [r.trait for r in rows]
self.trait_bar.lcombo.fill(ltraits)
self.trait_bar.rcombo.fill(rtraits)
if ltrait and ltrait in ltraits:
self.trait_bar.lcombo.set(ltrait)
else:
self.trait_bar.lcombo.set('')
if rtrait and rtrait in rtraits:
self.trait_bar.rcombo.set(rtrait)
else:
self.trait_bar.rcombo.set('')
def get_debconf(self, name, trait=None):
if trait is None:
trait = self.current_trait
clause = Eq('trait', trait) & Eq('name', name)
rows = self.cmd.select(clause=clause)
if len(rows) != 1:
raise Error, 'no debconf for %s in %s' % (name, trait)
return rows[0]
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 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 refreshlistView(self):
self.clear()
if self.ftype == 'template':
self.setColumnText(1, 'template')
elif self.ftype == 'script':
self.setColumnText(1, 'script')
if self.trait is None:
traits = self.traits.list()
else:
traits = [self.trait]
for trait in traits:
item = KListViewItem(self, trait)
item.trait = trait
if self.ftype == 'template':
for row in self.templates.templates(trait):
titem = KListViewItem(item, str(row.templatefile),
row.template, row.package)
titem.trait = trait
titem.row = row
elif self.ftype == 'script':
for row in self.scripts.cmd.select(clause=Eq('trait', trait),
order='script'):
sitem = KListViewItem(item, str(row.scriptfile),
row.script)
sitem.trait = trait
sitem.row = row
def environment_rows(self, family=None):
family = self._check_family(family)
clause = Eq('family', family)
args = dict(fields=['trait', 'name', 'value'],
clause=clause,
order=['trait', 'name'])
return self.env.cursor.select(**args)
def get_modules(self, machine_type=None):
if machine_type is None:
machine_type = self.current.machine_type
rows = self.cursor.select(table='machine_modules',
clause=Eq('machine_type', machine_type),
order='ord')
return [r.module for r in rows]
def ready_target(self):
self._check_target()
makepaths(self.target)
device = self.machine.array_hack(self.machine.current.machine_type)
clause = Eq('filesystem', self.machine.current.filesystem)
clause &= Gt('partition', '0')
table = 'filesystem_mounts natural join mounts'
mounts = self.cursor.select(table=table,
clause=clause,
order='mnt_point')
if mounts[0].mnt_point != '/':
raise Error, 'bad set of mounts', mounts
mddev = False
mdnum = 0
if device == '/dev/md':
mddev = True
pdev = '/dev/md0'
mdnum += 1
else:
pdev = self._pdev(device, mounts[0].partition)
print 'mounting target', pdev, self.target
clause &= Neq('mnt_point', '/')
mounts = self.cursor.select(table=table, clause=clause, order='ord')
runlog('mount %s %s' % (pdev, self.target))
for mnt in mounts:
tpath = os.path.join(self.target, mnt.mnt_point[1:])
makepaths(tpath)
if mddev:
pdev = '/dev/md%d' % mdnum
else:
pdev = self._pdev(device, mnt.partition)
mdnum += 1
runlog('mount %s %s' % (pdev, tpath))
self._mounted = True
def refreshlistView(self):
self.clear()
self.setColumnText(1, self.file_type)
if self.trait is None:
traits = self.traits.list()
else:
traits = [self.trait]
for trait in traits:
item = KListViewItem(self, trait)
item.trait = trait
# expand tree by default
item.setOpen(True)
if self.file_type == 'template':
for row in self.templates.templates(trait):
template_item = KListViewItem(item, str(row.templatefile),
row.template)
template_item.trait = trait
template_item.row = row
elif self.file_type == 'script':
# perhaps we need to make a method to obtain scriptnames
# in TraitScript object
for row in self.scripts.cmd.select(clause=Eq('trait', trait),
order='script'):
script_item = KListViewItem(item, str(row.scriptfile),
row.script)
script_item.trait = trait
script_item.row = row
else:
raise ValueError, "unknown file_type %s" % self.file_type
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 drop_variable(self, listbox, context, x, y, selection, targettype, time):
table = 'family_environment'
trips = [x.split('<=>') for x in selection.data.split('^&^')]
rows = [dict(trait=x[0], name=x[1], value=x[2]) for x in trips]
print rows
for r in trips:
clause = Eq('family', self.current_family)
clause &= Eq('trait', r[0]) & Eq('name', r[1])
trows = self.family.cursor.select(table=table, clause=clause)
print 'trows', trows
if len(trows) == 0:
data = dict(trait=r[0], name=r[1], value=r[2])
data['family'] = self.current_family
print 'data', data
self.family.cursor.insert(table=table, data=data)
self.__set_pages(self.current_family)
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()
def has_children(self, machine=None):
if machine is None:
self._check_machine_set()
machine = self.current_machine
clause = Eq('parent', machine)
rows = self.cursor.select(clause=clause)
return len(rows)
def export_trait(self, suite_path):
#print "----Begin export trait", self.current_trait
#print "start xml", self.current_trait
#xmldata = TraitElement(self.conn, self.suite)
xmldata = self._xmldata
#print 'set xml data'
xmldata.set(self.current_trait)
#print 'xml data set'
bkup_path = os.path.join(suite_path, self.current_trait)
makepaths(bkup_path)
#print 'render xml'
xmlfile = file(os.path.join(bkup_path, 'trait.xml'), 'w')
xmlfile.write(xmldata.toprettyxml())
xmlfile.close()
#print 'xml rendered'
#print "end xml", self.current_trait
row = self._traits.select_row(clause=Eq('trait', self.current_trait))
if row['description'] is not None:
print 'export description', self.current_trait
descfile = file(os.path.join(bkup_path, 'description.txt'), 'w')
descfile.write(row['description'])
descfile.close()
#print "start templates,scripts", self.current_trait
self._templates.export_templates(bkup_path)
self._scripts.export_scripts(bkup_path)
#print "end templates,scripts", self.current_trait
#print 'all exported', os.listdir(bkup_path)
print 'trait', self.current_trait, 'exported in suite', self.suite
def set_machine_type(self, machine_type):
clause = Eq('machine_type', machine_type)
self.clear_body()
self.mtype.set_machine_type(machine_type)
title = SimpleTitleElement('MachineType: %s' % machine_type,
bgcolor='IndianRed',
width='100%')
self.body.appendChild(title)
rows = self.cursor.select(table='machine_disks', clause=clause)
self._setup_section('Disks', ['diskname', 'device'], rows)
modrows = self.cursor.select(table='machine_modules',
clause=clause,
order=['ord'])
self._setup_section('Modules', ['module', 'ord'], modrows)
famrows = self.cursor.select(table='machine_type_family',
clause=clause,
order='family')
self._setup_section('Families', ['family'], famrows)
scripts = self.cursor.select(table='machine_type_scripts',
clause=clause,
order='script')
self._setup_section('Scripts', ['script'], scripts)
vars_ = self.cursor.select(table='machine_type_variables',
clause=clause,
order=['trait', 'name'])
self._setup_section('Variables', ['trait', 'name', 'value'], vars_)
self._make_footer_anchors('machine_type', machine_type)
def update_a_machine(self, machine, mtype, profile, kernel, fs):
clause = Eq('machine', machine)
data = dict(machine_type=mtype,
profile=profile,
kernel=kernel,
filesystem=fs)
self.cursor.update(table='machines', data=data, clause=clause)
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 get_row(self, name):
clause = Eq('name', name)
try:
row = self.cursor.select_row(table='archive_keys', clause=clause)
return row
except NoExistError:
msg = "There's no apt key named %s in the database" % name
raise NoAptKeyError , msg
def check_machine_disks(self, machine_type):
rows = self.mdisks.select(clause=Eq('machine_type', machine_type))
dn_dict = {}
for row in rows:
if row.diskname not in dn_dict.keys():
dn_dict[row.diskname] = []
dn_dict[row.diskname].append(row.device)
return dn_dict
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 set_machine(self, machine):
clause = Eq('machine', machine)
try:
row = self.cursor.select_row(table='machines', clause=clause)
except NoExistError:
msg = "There's no machine named %s" % machine
raise NoExistError, msg
self.current_machine = machine
def make_tagdict(self, family=None):
if family is not None:
self.set_family(family)
fclause = Eq('family', family)
fields = ['trait', 'name', 'value']
rows = self.cursor.select(fields=fields, clause=fclause)
items = [(r.trait + '_' + r.name, r.value) for r in rows]
return dict(items)
def insertVariable(self, trait, name, value, family=None):
family = self._check_family(family)
data = dict(family=family, trait=trait, name=name)
clause = reduce(and_, [Eq(k, v) for k,v in data.items()])
testrows = self.cursor.select(table='family_environment', clause=clause)
if not len(testrows):
data['value'] = value
self.cursor.insert(table='family_environment', data=data)
def set_parent(self, mtype, parent):
data = dict(parent=parent)
if self.get_parent(mtype) is None:
data.update(dict(machine_type=mtype))
self.insert(data=data)
else:
clause = Eq('machine_type', mtype)
self.update(data=data, clause=clause)
def _make_superdict__orig_(self):
clause = Eq('profile', self.profile)
superdict = {}
traits = [row.trait for row in self.cursor.select(fields=['trait'], clause=clause)]
for trait in traits:
self.set_trait(trait)
items = [(trait + '_' + key, value) for key, value in self.items()]
superdict.update(dict(items))
return superdict
def set_autoinstall(self, auto=True):
if auto:
value = 'True'
else:
value = 'False'
machine = self.current.machine
table = 'default_environment'
data = dict(section='autoinstall', option=machine, value=value)
clause = Eq('section', 'autoinstall') & Eq('option', machine)
rows = self.cursor.select(table=table, clause=clause)
if not len(rows):
self.cursor.insert(table=table, data=data)
elif len(rows) == 1:
self.cursor.update(table=table,
data=dict(value=value),
clause=clause)
else:
raise Error, 'too many rows for this machine: %s' % machine
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')
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 get_profile_list(self, suite=None):
if suite is None:
plist = [r.profile for r in self.select()]
elif suite == 'all':
plist = [(r.profile, r.suite) for r in self.select()]
else:
clause = Eq('suite', suite)
plist = [r.profile for r in self.select(clause=clause)]
return plist
def get_parent(self, mtype):
clause = Eq('machine_type', mtype)
try:
row = self.select_row(clause=clause)
# NoExistError should be raised on above statement
# if parent doesn't exist
return row.parent
except NoExistError:
return None
