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_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 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 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 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 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 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 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 __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 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 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 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 environment_rows(self, family=None):
if family is None:
family = self.current
clause = Eq('family', family)
args = dict(fields=['trait', 'name', 'value'],
clause=clause,
order=['trait', 'name'])
return self.env.cursor.select(**args)
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 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 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 partition_disks(self):
clause = Eq('machine_type', self.machine.current.machine_type)
disk_rows = self.cursor.select(table='machine_disks', clause=clause)
for row in disk_rows:
print 'partitioning', row.diskname, row.device
dump = self.machine.make_partition_dump(row.diskname, row.device)
i, o = os.popen2('sfdisk %s' % row.device)
i.write(dump)
i.close()
def set_template(self, package, template):
self.package = package
self.template = template
path = self.template_filename(package, template)
print self.trait, 'self.trait'
clause = Eq('trait', self.trait) & Eq('package', package) & Eq(
'template', template)
print 'clause', clause
template_text = self.traittemplate.templatedata(package, template)
self.workspace.set_text(template_text)
self.template_view.set_text(template_text)
if self.extracted:
path = join(self.trait_temp_path(), package, template)
try:
self.original_view.set_text(readfile(path))
except NoExistError:
pass
except IOError:
pass
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 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 __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')
self.__set_droptargets__(pages)
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')
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 make_partition_dump(self, diskname, device):
rows = self.partitions.select(clause=Eq('diskname', diskname))
firstline = '# partition table of %s' % device
secondline = 'unit: sectors'
blankline = ''
plines = []
for row in rows:
line = '%s%s : start=%9d, size=%9d, Id=%d' % \
(device, row.partition, int(row.start), int(row.size), int(row.id))
plines.append(line)
return '\n'.join([firstline, secondline, blankline] + plines) + '\n'
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 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 set_template(self, package, template):
self.package = package
self.template = template
path = self.template_filename(package, template)
clause = Eq('trait', self.trait) & Eq('package', package) & Eq('template', template)
row = self.cmd.cmd.select(fields=['templatefile'], clause=clause)[0]
filename = row.templatefile.name
tfile = self.cmd.cmd.openfile(self.conn, filename)
template_text = tfile.read()
tfile.close()
self.workspace.set_text(template_text)
self.template_view.set_text(template_text)
if self.extracted:
path = join(self.trait_temp_path(), package, template)
try:
self.original_view.set_text(readfile(path))
except NoExistError:
pass
except IOError:
pass
def set_action(self, action, packages, trait=None):
if trait is None:
trait = self.current_trait
clause = Eq('trait', trait) & In('package', packages)
if action == 'drop':
self.cmd.delete(clause=clause)
elif action in ['remove', 'install', 'purge']:
self.cmd.set_data({'action' : action})
self.cmd.update(clause=clause)
else:
raise Error, 'bad action in TraitPackage -%s-' % action