def addDbSchemaok(self): dlg = self.dialogs['new-schema'] schema = str(dlg.grid.entries['schema'].text()) self.manager.create_schema(schema) cursor = StatementCursor(self.db.conn) cursor.execute('set SESSION search_path to %s' % schema) self.db.conn.commit() cursor.execute('show search_path') print cursor.fetchall() kschema.create_schema(cursor) self.refreshlistView()
def remove_client(self, client): profiles, families, traits = self._client_schema(client) disks, mtypes, machines = self._client_mdata(client) cursor = StatementCursor(self.conn) if machines: cursor.delete(table='machines', clause=In('machine', machines)) for mtype in mtypes: cursor.execute("select * from delete_mtype('%s')" % mtype) for disk in disks: cursor.execute("select * from delete_disk('%s')" % disk) for profile in profiles: cursor.execute("select * from delete_profile('%s')" % profile) for family in families: cursor.execute("select * from delete_family('%s')" % family)
def remove_client(self, client): profiles, families, traits = self._client_schema(client) machines = self._client_mdata(client) cursor = StatementCursor(self.conn) for machine in machines: cursor.execute("select * from delete_machine('%s')" % machine) for profile in profiles: cursor.execute("select * from delete_profile('%s')" % profile) for family in families: cursor.execute("select * from delete_family('%s')" % family)
def create_database(cfg, default_traits): dsn = cfg.get_dsn() dsn['dbname'] = 'mishmash' conn = QuickConn(dsn) cmd = StatementCursor(conn, 'create_database') for table in cmd.tables(): cmd.execute('drop table %s' %table) start_schema(conn, default_traits) make_suites(conn) cmd.execute(grant_public(cmd.tables())) cmd.execute(grant_public(['current_environment'], 'ALL'))
def create_database(cfg, default_traits): dsn = cfg.get_dsn() dsn['dbname'] = 'mishmash' conn = QuickConn(dsn) cmd = StatementCursor(conn, 'create_database') for table in cmd.tables(): cmd.execute('drop table %s' % table) start_schema(conn, default_traits) make_suites(conn) cmd.execute(grant_public(cmd.tables())) cmd.execute(grant_public(['current_environment'], 'ALL'))
class Family(object): def __init__(self, conn): object.__init__(self) self.conn = conn #self.suites = Suites(conn).list() self.cursor = StatementCursor(self.conn) self.suites = [r.suite for r in self.cursor.select(table='suites')] self.current = None self.parent = SimpleRelation(self.conn, 'family_parent', 'family') self.env = FamilyEnvironment(self.conn) def set_family(self, family): self.current = family self.parent.set_current(family) self.env.set_family(family) def _check_family(self, family): if family is not None: return family else: family = self.current if family is None: raise Error, 'either pass a family arguement or call set_family on this object' return family def add_family(self, family, type='general'): pass def get_related_families(self, families=[]): rows = self.cursor.select(table='family_parent') graph = kjGraph([(r.family, r.parent) for r in rows]) dfamilies = Set() for fam in families: dfamilies |= Set([fam]) | Set(graph.reachable(fam).items()) return dfamilies def parent_rows(self, family=None): family = self._check_family(family) self.parent.set_clause(family) rows = self.parent.cmd.select(fields=['parent'], order='parent') self.parent.reset_clause() return rows def parents(self, family=None): family = self._check_family(family) rows = self.parent_rows(family) return [x.parent for x in rows] 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 family_rows(self): return self.cursor.select(fields=['family'], table='families', order='family') def all_families(self): return [r.family for r in self.family_rows()] def get_all_defaults(self): stmt = select_multisuite_union(self.suites, 'variables') print stmt self.cursor.execute(stmt) return self.cursor.fetchall() def create_family(self, family): if family not in self.all_families(): self.cursor.insert(table='families', data=dict(family=family)) else: raise ExistsError, '%s already exists' % family def insert_parents(self, parents, family=None): family = self._check_family(family) self.parent.insert('parent', parents) def FamilyData(self, families=[]): if families is None: families = [self.current] all = self.make_familylist(families) superdict = {} for f in all: superdict.update(self.env.make_tagdict(f)) return superdict def make_familylist(self, families): deps = families all = list(self.get_related_families(families)) setfun = self.set_family parfun = self.parents return make_deplist(deps, all, setfun, parfun) def export_family(self, family=None): if family is None: family = self.current element = FamilyElement(family) element.append_parents(self.parents(family)) element.append_variables(self.environment_rows(family)) return element def write_family(self, family, path): fxml = file(join(path, '%s.xml' % family), 'w') data = self.export_family(family) data.writexml(fxml, indent='\t', newl='\n', addindent='\t') fxml.close() def export_families(self, path): families = self.all_families() for f in families: self.write_family(f, path) def import_family(self, element): parsed = FamilyParser(element) print 'inserting family', parsed.name all = self.all_families() for p in parsed.parents: if p not in all: print 'insertion failed for', parsed.name raise UnbornError self.create_family(parsed.name) self.set_family(parsed.name) self.insert_parents(parsed.parents) row = dict(family=parsed.name) for var in parsed.environ: row.update(var) self.cursor.insert(table='family_environment', data=row) def _import_family_xml(self, xmlfile): xml = parse_file(xmlfile) elements = xml.getElementsByTagName('family') if len(elements) != 1: raise Error, 'bad number of family tags %s' % len(elements) element = elements[0] return element def import_family_xml(self, xmlfile): element = self._import_family_xml(xmlfile) self.import_family(element) def import_families(self, path): xmlfiles = [join(path, x) for x in os.listdir(path) if x[-4:] == '.xml'] families = [] for f in xmlfiles: element = self._import_family_xml(f) families.append(element) while len(families): f = families[0] try: self.import_family(f) except UnbornError: families.append(f) del families[0] print len(families), 'families inserted' def getVariablesConfig(self, family=None): family = self._check_family(family) return FamilyVariablesConfig(self.conn, family) def deleteVariable(self, trait, name, 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()]) self.env.cursor.delete(clause=clause) 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)
class BaseDatabase(QSqlDatabase): def __init__(self, dsn, name, parent=None, objname=None): deprecated('useless.kdedb.BaseDatabase is deprecated') QSqlDatabase.__init__(self, 'QPSQL7', name, parent, objname) if hasattr(dsn, 'items'): #if dsn is dictionary self.conn = BasicConnection(**dsn) self.setDatabaseName(dsn['dbname']) self.setHostName(dsn['host']) self.dbuser = dsn['user'] else: #else a conn was passed as dsn self.conn = dsn self.setDatabaseName(self.conn.conn.db) self.setHostName(self.conn.conn.host) self.dbuser = self.conn.conn.user self.setUserName(self.dbuser) self.stmt = Statement() self.mcursor = StatementCursor(self.conn) def set_table(self, table): self.stmt.table = table def set_clause(self, items, cmp='=', join='and'): self.stmt.set_clause(items, cmp=cmp, join=join) def set_data(self, data): self.stmt.set(data) def set_fields(self, fields): self.stmt.fields = fields def qdelete(self, table=None, clause=None): query = self.stmt.delete(table=table, clause=clause) return self.execStatement(query) def qinsert(self, table=None, data=None): query = self.stmt.insert(table=table, data=data) return self.execStatement(query) def qupdate(self, table=None, data=None, clause=None): query = self.stmt.update(table=table, data=data, clause=clause) return self.execStatement(query) def qselect(self, fields=None, table=None, clause=None, group=None, having=None, order=None): query = self.stmt.select(fields=fields, table=table, clause=clause, group=group, having=having, order=order) return self.execStatement(query) def delete(self, table=None, clause=None): query = self.stmt.delete(table=table, clause=clause) return self.mcursor.execute(query) def insert(self, table=None, data=None): query = self.stmt.insert(table=table, data=data) return self.mcursor.execute(query) def update(self, table=None, data=None, clause=None): query = self.stmt.update(table=table, data=data, clause=clause) return self.mcursor.execute(query) def select(self, fields=None, table=None, clause=None, group=None, having=None, order=None): query = self.stmt.select(fields=fields, table=table, clause=clause, group=group, having=having, order=order) self.mcursor.execute(query) return self.mcursor.fetchall() def select_row(self, fields=None, table=None, clause=None, group=None, having=None, order=None): query = self.stmt.select(fields=fields, table=table, clause=clause, group=group, having=having, order=order) self.mcursor.execute(query) rows = len(self.mcursor) if rows == 1: return self.mcursor.next() elif rows == 0: raise NoExistError else: raise RuntimeError, 'bad row count %s' % rows def clear(self, **args): self.stmt.clear(**args) def stdclause(self, data): return reduce(and_, [Eq(k, v) for k,v in data.items()]) def insertData(self, idcol, table, data, commit=True): clause = self.stdclause(data) try: self.mcursor.select_row(fields=[idcol], table=table, clause=clause) except NoExistError: self.mcursor.insert(table=table, data=data) if commit: self.conn.commit() def identifyData(self, idcol, table, data, commit=True): clause = self.stdclause(data) self.insertData(idcol, table, data, commit=commit) return self.mcursor.select_row(fields=['*'], table=table, clause=clause)
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 BaseDatabase(object): def __init__(self, conn=None): if conn is None: self.conn = KonsultantConnection() else: self.conn = conn self.stmt = Statement() self.mcursor = StatementCursor(self.conn) def set_table(self, table): self.stmt.table = table def set_clause(self, items, cmp='=', join='and'): self.stmt.set_clause(items, cmp=cmp, join=join) def set_data(self, data): self.stmt.set(data) def set_fields(self, fields): self.stmt.fields = fields def delete(self, table=None, clause=None): query = self.stmt.delete(table=table, clause=clause) return self.mcursor.execute(query) def insert(self, table=None, data=None): query = self.stmt.insert(table=table, data=data) return self.mcursor.execute(query) def update(self, table=None, data=None, clause=None): query = self.stmt.update(table=table, data=data, clause=clause) return self.mcursor.execute(query) def select(self, fields=None, table=None, clause=None, group=None, having=None, order=None): query = self.stmt.select(fields=fields, table=table, clause=clause, group=group, having=having, order=order) self.mcursor.execute(query) return self.mcursor.fetchall() def select_row(self, fields=None, table=None, clause=None, group=None, having=None, order=None): query = self.stmt.select(fields=fields, table=table, clause=clause, group=group, having=having, order=order) self.mcursor.execute(query) rows = len(self.mcursor) if rows == 1: return self.mcursor.next() elif rows == 0: raise NoExistError else: raise Error, 'bad row count %s' % rows def clear(self, **args): self.stmt.clear(**args) def stdclause(self, data): return reduce(and_, [Eq(k, v) for k,v in data.items()]) def insertData(self, idcol, table, data, commit=True): clause = self.stdclause(data) try: self.mcursor.select_row(fields=[idcol], table=table, clause=clause) except NoExistError: self.mcursor.insert(table=table, data=data) if commit: self.conn.commit() def identifyData(self, idcol, table, data, commit=True): clause = self.stdclause(data) self.insertData(idcol, table, data, commit=commit) return self.mcursor.select_row(fields=['*'], table=table, clause=clause)
class SuiteHandler(object): def __init__(self, conn, cfg): self.conn = conn self.cfg = cfg self.cursor = StatementCursor(self.conn) self.http_mirror = 'http://%s' % self.cfg.get('debrepos', 'repos_host') self.local_mirror = 'file:/tmp/paellamirror' self.suite = None self.sources_rows = [] def set_suite(self, suite): self.suite = suite self.sources_rows = self.get_sources_rows(self.suite) def make_suite(self): if self.suite is None: raise Error, 'the suite needs to be set first' self._make_suite_tables() self.update_packagelists() for row in self.sources_rows: self._insert_packages(row) def _make_suite_tables(self): tables = suite_tables(self.suite) map(self.cursor.create_table, tables) self.cursor.execute(grant_public([x.name for x in tables])) def update_packagelists(self): self._update_suite_packages(self.suite) def get_sources_rows(self, suite): table = 'apt_sources natural join suite_apt_sources' rows = self.cursor.select(table=table, clause=Eq('suite', suite), order=['ord']) return rows def _insert_some_packages(self, table, packages): for package in packages: try: self.cursor.insert(table, data=package_to_row(package)) except OperationalError: pass def _insert_packages(self, src_row): table = '%s_packages' % self.suite repos = self._row2repos(src_row) prow = package_to_row local = repos.local if local.source.sections: repos.update() local.parse_release() for section in local.source.sections: packages = local.full_parse(section).values() self._insert_some_packages(table, packages) else: packages = local.full_parse().values() self._insert_some_packages(table, packages) def _row2repsource(self, row, http_mirror): lp = row.local_path while lp[0] == '/': lp = lp[1:] uri = os.path.join(http_mirror, lp) suite = row.dist src = 'deb %s %s' % (uri, suite) if not suite.endswith('/'): src = '%s %s' % (src, row.sections) r = RepositorySource(src) return r def _row2repos(self, row): rsource = self._row2repsource(row, self.http_mirror) lsource = self._row2repsource(row, self.local_mirror) return RemoteRepos(rsource, lsource) def _get_packages_file(self, repos): if repos.source.has_release(): repos.update() else: rpath = os.path.join(repos.source.uri, repos.source.suite, 'Packages.gz') # the [5:] slice is to remove file: from local uri lpath = os.path.join(repos.local.source.uri, repos.source.suite, 'Packages.gz')[5:] if not os.path.isfile(lpath): print 'lpath is --->', lpath makepaths(os.path.dirname(lpath)) print rpath, lpath, 'getting now' wget(rpath, lpath) def _update_suite_packages(self, suite): rows = self.get_sources_rows(suite) for row in rows: repos = self._row2repos(row) self._get_packages_file(repos)
def start_schema(conn): cursor = StatementCursor(conn, 'start_schema') map(cursor.create_sequence, primary_sequences()) tables, mapping = primary_tables() map(cursor.create_table, tables) priorities_table = mapping['priorities'] insert_list(cursor, priorities_table.name, 'priority', PRIORITIES) insert_list(cursor, 'scriptnames', 'script', SCRIPTS) newscripts = [s for s in MTSCRIPTS if s not in SCRIPTS] insert_list(cursor, 'scriptnames', 'script', newscripts) cursor.execute(grant_public([x.name for x in tables])) cursor.execute(grant_public(['current_environment'], 'ALL')) cursor.execute(grant_public(['partition_workspace'], 'ALL')) cursor.execute(plpgsql_delete_trait) cursor.execute(pgsql_delete_profile()) cursor.execute(pgsql_delete_family()) cursor.execute(pgsql_delete_disk()) cursor.execute(pgsql_delete_mtype()) cursor.execute(pgsql_delete_filesystem())
class Family(object): def __init__(self, conn): object.__init__(self) self.conn = conn self.cursor = StatementCursor(self.conn) self.current = None self.parent = SimpleRelation(self.conn, 'family_parent', 'family') self.env = FamilyEnvironment(self.conn) def set_family(self, family): self.current = family self.parent.set_current(family) self.env.set_family(family) def _check_family(self, family): if family is not None: return family else: family = self.current if family is None: raise Error, 'either pass a family arguement or call set_family on this object' return family def add_family(self, family, type='general'): pass def get_related_families(self, families=[]): rows = self.cursor.select(table='family_parent') graph = kjGraph([(r.family, r.parent) for r in rows]) dfamilies = Set() for fam in families: dfamilies |= Set([fam]) | Set(graph.reachable(fam).items()) return dfamilies def parent_rows(self, family=None): family = self._check_family(family) self.parent.set_clause(family) rows = self.parent.cmd.select(fields=['parent'], order='parent') self.parent.reset_clause() return rows def parents(self, family=None): family = self._check_family(family) rows = self.parent_rows(family) return [x.parent for x in rows] 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 family_rows(self): return self.cursor.select(fields=['family'], table='families', order='family') def all_families(self): return [r.family for r in self.family_rows()] def get_all_defaults(self): suite_cursor = SuiteCursor(self.conn) suites = suite_cursor.get_suites() stmt = select_multisuite_union(suites, 'variables') print stmt self.cursor.execute(stmt) return self.cursor.fetchall() def create_family(self, family): if family not in self.all_families(): self.cursor.insert(table='families', data=dict(family=family)) else: raise ExistsError, '%s already exists' % family def insert_parents(self, parents, family=None): family = self._check_family(family) self.parent.insert('parent', parents) def FamilyData(self, families=[]): if families is None: families = [self.current] all = self.make_familylist(families) superdict = {} for f in all: superdict.update(self.env.make_tagdict(f)) return superdict def make_familylist(self, families): deps = families all = list(self.get_related_families(families)) setfun = self.set_family parfun = self.parents return make_deplist(deps, all, setfun, parfun) def export_family(self, family=None): if family is None: family = self.current element = FamilyElement(family) element.append_parents(self.parents(family)) element.append_variables(self.environment_rows(family)) return element def write_family(self, family, path): fxml = file(join(path, '%s.xml' % family), 'w') data = self.export_family(family) data.writexml(fxml, indent='\t', newl='\n', addindent='\t') fxml.close() def export_families(self, path): families = self.all_families() self.report_total_families(len(families)) for f in families: self.write_family(f, path) self.report_family_exported(f, path) def import_family(self, element): parsed = FamilyParser(element) print 'inserting family', parsed.name all = self.all_families() for p in parsed.parents: if p not in all: print 'insertion failed for', parsed.name raise UnbornError self.create_family(parsed.name) self.set_family(parsed.name) self.insert_parents(parsed.parents) row = dict(family=parsed.name) for var in parsed.environ: row.update(var) self.cursor.insert(table='family_environment', data=row) def _import_family_xml(self, xmlfile): xml = parse_file(xmlfile) elements = xml.getElementsByTagName('family') if len(elements) != 1: raise Error, 'bad number of family tags %s' % len(elements) element = elements[0] return element def import_family_xml(self, xmlfile): element = self._import_family_xml(xmlfile) self.import_family(element) def import_families(self, path): xmlfiles = [join(path, x) for x in os.listdir(path) if x[-4:] == '.xml'] families = [] for f in xmlfiles: element = self._import_family_xml(f) families.append(element) while len(families): f = families[0] try: self.import_family(f) except UnbornError: families.append(f) del families[0] print len(families), 'families inserted' def getVariablesConfig(self, family=None): family = self._check_family(family) return FamilyVariablesConfig(self.conn, family) def deleteVariable(self, trait, name, 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()]) self.env.cursor.delete(clause=clause) 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 report_family_exported(self, family, path): print 'family %s exported to %s' % (family, path) def report_total_families(self, total): print 'exporting %d families' % total
class Family(object): def __init__(self, conn): object.__init__(self) self.conn = conn self.cursor = StatementCursor(self.conn) self.current = None self.parent = SimpleRelation(self.conn, 'family_parent', 'family') self.env = FamilyEnvironment(self.conn) def set_family(self, family): self.current = family self.parent.set_current(family) self.env.set_family(family) def _check_family(self, family): if family is not None: return family else: family = self.current if family is None: raise Error, 'either pass a family argument or call set_family on this object' return family def get_related_families(self, families=[]): rows = self.cursor.select(table='family_parent') graph = kjGraph([(r.family, r.parent) for r in rows]) dfamilies = Set() for fam in families: dfamilies |= Set([fam]) | Set(graph.reachable(fam).items()) return dfamilies def parent_rows(self, family=None): family = self._check_family(family) self.parent.set_clause(family) rows = self.parent.cmd.select(fields=['parent'], order='parent') self.parent.reset_clause() return rows def parents(self, family=None): family = self._check_family(family) rows = self.parent_rows(family) return [x.parent for x in rows] 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 family_rows(self): return self.cursor.select(fields=['family'], table='families', order='family') def all_families(self): return [r.family for r in self.family_rows()] def get_all_defaults(self): suite_cursor = SuiteCursor(self.conn) suites = suite_cursor.get_suites() stmt = select_multisuite_union(suites, 'variables') print stmt self.cursor.execute(stmt) return self.cursor.fetchall() def create_family(self, family): if family not in self.all_families(): self.cursor.insert(table='families', data=dict(family=family)) else: raise ExistsError, '%s already exists' % family def delete_family(self, family=None): family = self._check_family(family) self.cursor.execute("select * from delete_family('%s')" % family) def insert_parents(self, parents, family=None): family = self._check_family(family) self.parent.insert('parent', parents) def delete_parents(self, parents=[], family=None): family = self._check_family(family) if not parents: parents = self.parents() if not parents: return table = 'family_parent' clause = Eq('family', family) & In('parent', parents) self.cursor.delete(table=table, clause=clause) def FamilyData(self, families=[]): # change sep here sep = PAELLA_TRAIT_NAME_SEP # we don't know what to do here # it is possible to have an empty # list of families, and if that's the # case we don't need to make the # list of [self.current] . I need to look # for everywhere this method is called. # In the installer, the family is never set, # and we use the list of families provided # by the profile and the machine. In this # case, the families argument will always # be a list, empty or not. # I can't think of any other circumstance # where this method would be called outside # of the installer, or a script, and the script # should be using either a profile or machine # to get the list of families anyway, make the # point moot. I will probably remove this part # of the code in the near future, once I'm sure # that there's no reason to pass None to the # families argument. if families is None: families = [self.current] all = self.make_familylist(families) superdict = {} for f in all: superdict.update(self.env.make_tagdict(f, sep=sep)) return superdict def make_familylist(self, families): deps = families all = list(self.get_related_families(families)) setfun = self.set_family parfun = self.parents return make_deplist(deps, all, setfun, parfun) def export_family(self, family=None): if family is None: family = self.current # row isn't used, except to determine that the family exists row = self.cursor.select_row(table='families', clause=Eq('family', family)) element = FamilyElement(family) element.append_parents(self.parents(family)) element.append_variables(self.environment_rows(family)) return element def write_family(self, family, path): fxml = file(join(path, '%s.xml' % family), 'w') data = self.export_family(family) data.writexml(fxml, indent='\t', newl='\n', addindent='\t') fxml.close() def export_families(self, path): families = self.all_families() self.report_total_families(len(families)) for f in families: self.write_family(f, path) self.report_family_exported(f, path) def import_family(self, element): parsed = FamilyParser(element) print 'inserting family', parsed.name all = self.all_families() for p in parsed.parents: if p not in all: print 'insertion failed for', parsed.name raise UnbornError self.create_family(parsed.name) self.set_family(parsed.name) self.insert_parents(parsed.parents) row = dict(family=parsed.name) for var in parsed.environ: row.update(var) self.cursor.insert(table='family_environment', data=row) def _import_family_xml(self, xmlfile): xml = parse_file(xmlfile) elements = xml.getElementsByTagName('family') if len(elements) != 1: raise Error, 'bad number of family tags %s' % len(elements) element = elements[0] return element def import_family_xml(self, xmlfile): element = self._import_family_xml(xmlfile) self.import_family(element) def import_families(self, path): xmlfiles = [ join(path, x) for x in os.listdir(path) if x[-4:] == '.xml' ] families = [] for f in xmlfiles: element = self._import_family_xml(f) families.append(element) while len(families): f = families[0] try: self.import_family(f) except UnbornError: families.append(f) del families[0] print len(families), 'families inserted' def getVariablesConfig(self, family=None): family = self._check_family(family) return FamilyVariablesConfig(self.conn, family) def deleteVariable(self, trait, name, 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()]) self.env.cursor.delete(clause=clause) 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 report_family_exported(self, family, path): print 'family %s exported to %s' % (family, path) def report_total_families(self, total): print 'exporting %d families' % total
class Family(object): def __init__(self, conn): object.__init__(self) self.conn = conn self.cursor = StatementCursor(self.conn) self.current = None self.parent = SimpleRelation(self.conn, 'family_parent', 'family') self.env = FamilyEnvironment(self.conn) def set_family(self, family): self.current = family self.parent.set_current(family) self.env.set_family(family) def _check_family(self, family): if family is not None: return family else: family = self.current if family is None: raise Error, 'either pass a family argument or call set_family on this object' return family def get_related_families(self, families=[]): rows = self.cursor.select(table='family_parent') graph = kjGraph([(r.family, r.parent) for r in rows]) dfamilies = Set() for fam in families: dfamilies |= Set([fam]) | Set(graph.reachable(fam).items()) return dfamilies def parent_rows(self, family=None): family = self._check_family(family) self.parent.set_clause(family) rows = self.parent.cmd.select(fields=['parent'], order='parent') self.parent.reset_clause() return rows def parents(self, family=None): family = self._check_family(family) rows = self.parent_rows(family) return [x.parent for x in rows] 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 family_rows(self): return self.cursor.select(fields=['family'], table='families', order='family') def all_families(self): return [r.family for r in self.family_rows()] def get_all_defaults(self): suite_cursor = SuiteCursor(self.conn) suites = suite_cursor.get_suites() stmt = select_multisuite_union(suites, 'variables') print stmt self.cursor.execute(stmt) return self.cursor.fetchall() def create_family(self, family): if family not in self.all_families(): self.cursor.insert(table='families', data=dict(family=family)) else: raise ExistsError, '%s already exists' % family def delete_family(self, family=None): family = self._check_family(family) self.cursor.execute("select * from delete_family('%s')" % family) def insert_parents(self, parents, family=None): family = self._check_family(family) self.parent.insert('parent', parents) def delete_parents(self, parents=[], family=None): family = self._check_family(family) if not parents: parents = self.parents() if not parents: return table= 'family_parent' clause = Eq('family', family) & In('parent', parents) self.cursor.delete(table=table, clause=clause) def FamilyData(self, families=[]): # change sep here sep = PAELLA_TRAIT_NAME_SEP # we don't know what to do here # it is possible to have an empty # list of families, and if that's the # case we don't need to make the # list of [self.current] . I need to look # for everywhere this method is called. # In the installer, the family is never set, # and we use the list of families provided # by the profile and the machine. In this # case, the families argument will always # be a list, empty or not. # I can't think of any other circumstance # where this method would be called outside # of the installer, or a script, and the script # should be using either a profile or machine # to get the list of families anyway, make the # point moot. I will probably remove this part # of the code in the near future, once I'm sure # that there's no reason to pass None to the # families argument. if families is None: families = [self.current] all = self.make_familylist(families) superdict = {} for f in all: superdict.update(self.env.make_tagdict(f, sep=sep)) return superdict def make_familylist(self, families): deps = families all = list(self.get_related_families(families)) setfun = self.set_family parfun = self.parents return make_deplist(deps, all, setfun, parfun) def export_family(self, family=None): if family is None: family = self.current # row isn't used, except to determine that the family exists row = self.cursor.select_row(table='families', clause=Eq('family', family)) element = FamilyElement(family) element.append_parents(self.parents(family)) element.append_variables(self.environment_rows(family)) return element def write_family(self, family, path): fxml = file(join(path, '%s.xml' % family), 'w') data = self.export_family(family) data.writexml(fxml, indent='\t', newl='\n', addindent='\t') fxml.close() def export_families(self, path): families = self.all_families() self.report_total_families(len(families)) for f in families: self.write_family(f, path) self.report_family_exported(f, path) def import_family(self, element): parsed = FamilyParser(element) print 'inserting family', parsed.name all = self.all_families() for p in parsed.parents: if p not in all: print 'insertion failed for', parsed.name raise UnbornError self.create_family(parsed.name) self.set_family(parsed.name) self.insert_parents(parsed.parents) row = dict(family=parsed.name) for var in parsed.environ: row.update(var) self.cursor.insert(table='family_environment', data=row) def _import_family_xml(self, xmlfile): xml = parse_file(xmlfile) elements = xml.getElementsByTagName('family') if len(elements) != 1: raise Error, 'bad number of family tags %s' % len(elements) element = elements[0] return element def import_family_xml(self, xmlfile): element = self._import_family_xml(xmlfile) self.import_family(element) def import_families(self, path): xmlfiles = [join(path, x) for x in os.listdir(path) if x[-4:] == '.xml'] families = [] for f in xmlfiles: element = self._import_family_xml(f) families.append(element) while len(families): f = families[0] try: self.import_family(f) except UnbornError: families.append(f) del families[0] print len(families), 'families inserted' def getVariablesConfig(self, family=None): family = self._check_family(family) return FamilyVariablesConfig(self.conn, family) def deleteVariable(self, trait, name, 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()]) self.env.cursor.delete(clause=clause) 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 report_family_exported(self, family, path): print 'family %s exported to %s' % (family, path) def report_total_families(self, total): print 'exporting %d families' % total
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)