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