class MachineTypeHandler(BaseMachineTypeHandler): def __init__(self, conn): BaseMachineTypeHandler.__init__(self, conn) self._mtfam = MachineTypeFamily(self.conn) self._fam = Family(self.conn) self._mtscript = MachineTypeScript(self.conn) def set_machine_type(self, machine_type): BaseMachineTypeHandler.set_machine_type(self, machine_type) self._mtenv = MachineTypeEnvironment(self.conn, machine_type) self._mtcfg = MachineTypeVariablesConfig(self.conn, machine_type) self._mtscript.set_machine_type(machine_type) def family_rows(self): clause = self._mtype_clause() return self._mtfam.select(clause=clause, order='family') def _family_clause(self, family): return self._mtype_clause() & Eq('family', family) def append_family(self, family): if family not in self.get_families(): data = dict(machine_type=self.current, family=family) self._mtfam.insert(data=data) def delete_family(self, family): clause = self._family_clause(family) self._mtfam.delete(clause=clause) def update_family(self, oldfam, newfam): clause = self._family_clause(oldfam) self._mtfam.update(data=dict(family=newfam), clause=clause) def append_variable(self, trait, name, value): data = dict(trait=trait, name=name, value=value, machine_type=self.current) self._mtenv.cursor.insert(data=data) def _variable_clause(self, trait, name): return self._mtype_clause() & Eq('trait', trait) & Eq('name', name) def delete_variable(self, trait, name): clause = self._variable_clause(trait, name) self._mtenv.cursor.delete(clause=clause) def update_variable(self, trait, name, value): clause = self._variable_clause(trait, name) self._mtenv.update(data=dict(value=value), clause=clause) def edit_variables(self): newvars = self._mtcfg.edit() self._mtcfg.update(newvars) def edit_script(self, name): script = self.get_script(name) if script is not None: data = edit_dbfile(name, script.read(), 'script') if data is not None: self._mtscript.save_script(name, strfile(data)) print 'need to update' def get_families(self): return [r.family for r in self.family_rows()] def get_family_data(self): families = self.get_families() return self._fam.FamilyData(families) def get_machine_type_data(self): data = self.get_family_data() data.update(self.MachineTypeData()) return data def MachineTypeData(self): return self._mtenv._make_superdict_() def get_script(self, name): return self._mtscript.get(name) def insert_script(self, name, scriptfile): self._mtscript.insert_script(name, scriptfile) def delete_script(self, name): self._mtscript.delete_script(name) def insert_parsed_element(self, mtype_element, path): mtype = mtype_element.mtype self.add_new_type(mtype.name) self.set_machine_type(mtype.name) mdisktable = 'machine_disks' for mdisk in mtype.disks: mdisk['machine_type'] = mtype.name self.insert(table=mdisktable, data=mdisk) mod_items = zip(range(len(mtype.modules)), mtype.modules) data = dict(machine_type=mtype.name) for i in range(len(mtype.modules)): data['ord'] = str(i) data['module'] = mtype.modules[i] self.insert(table='machine_modules', data=data) data = dict(machine_type=mtype.name) for f in mtype.families: data['family'] = f self.insert(table='machine_type_family', data=data) for s, d in mtype.scripts: scriptfile = file(join(path, 'script-%s' % s)) self._mtscript.insert_script(s, scriptfile) print 'imported %s' % s for trait, name, value in mtype.variables: data = dict(machine_type=mtype.name, trait=trait, name=name, value=value) self.insert(table='machine_type_variables', data=data) def import_machine_type_ignore(self, name, mtypepath): path = join(mtypepath, name) def import_machine_type(self, element, name): path = join(element.mtypepath, name) element = parseString(file(join(path, 'machine_type.xml')).read()) parsed = MachineTypeParser(element.firstChild) self.insert_parsed_element(parsed, path) def export_machine_type(self, mtype, mtypepath): path = join(mtypepath, mtype) element = MachineTypeElement(self.conn, mtype) element.export(mtypepath) self._mtscript.export_scripts(path)
class MachineRelations(BaseMachineDbObject): "Class to hold the relations" def __init__(self, conn): BaseMachineDbObject.__init__(self, conn, table='machines') self.parents = MachineParents(self.conn) self.scripts = MachineScripts(self.conn) self.family = MachineFamily(self.conn) self.environment = MachineEnvironment(self.conn) self.config = None # These aren't really actual relations in the # same sense that the above objects are # but they are objects the the machines # table relates to, and should fit nicely in this # class. self.diskconfig = DiskConfigHandler(self.conn) self.kernels = Table_cursor(self.conn, 'kernels') # This is the main family class self.mainfamily = Family(self.conn) def set_machine(self, machine): BaseMachineDbObject.set_machine(self, machine) self.parents.set_machine(machine) self.scripts.set_machine(machine) self.family.set_machine(machine) self.environment.set_machine(machine) self.config = MachineVariablesConfig(self.conn, machine) def get_families(self, inherited=False, show_inheritance=False, machine=None): if machine is None: self._check_machine_set() machine = self.current_machine if show_inheritance: inherited = True families = self.family.get_families(machine=machine) if inherited: famlist = [] parents = self.parents.get_parent_list(childfirst=False) for parent in parents: pfam = self.family.get_families(parent) if pfam: famlist.append((parent, pfam)) if show_inheritance: return families, famlist else: for parent, pfam in famlist: for family in pfam: if family not in families: families.append(family) return families def get_script(self, name, inherited=False, show_inheritance=False): scriptfile = self.scripts.get(name) if show_inheritance: inherited = True # if we get the scriptfile without checking # through the parents, we go ahead and return # it if scriptfile is not None: if show_inheritance: return scriptfile, None else: return scriptfile # if we get here, the scriptfile is None # so we need to check through the parents. if not inherited: # if we're not asking for inheritance, we # go ahead and return the scriptfile return scriptfile else: # otherwise, we traverse the parents looking # for the script parents = self.parents.get_parent_list(childfirst=True) for parent in parents: scriptfile = self.scripts.get(name, parent) #print parent, scriptfile if scriptfile is not None: if show_inheritance: return scriptfile, parent else: return scriptfile # if we didn't find a script above, there isn't one # and we return None return None def edit_script(self, name): self._check_machine_set() scriptfile = self.get_script(name, inherited=False) if scriptfile is not None: content = edit_dbfile(name, scriptfile.read(), 'script') if content is not None: self.scripts.save_script(name, strfile(content)) def _get_row(self, machine): clause = self._machine_clause_(machine) return self.cursor.select_row(clause=clause) # this is the helper function for determining # the diskconfig, kernel, or profile def get_attribute(self, attribute, show_inheritance=False): parents = self.parents.get_parent_list(childfirst=True) for parent in parents: row = self._get_row(parent) if row[attribute] is not None: if show_inheritance: return row[attribute], parent else: return row[attribute] # there's a probem if the for loop completes without # finding the attribute. msg = "%s must be set somewhere in the hierarchy of machines" % attribute raise AttributeUnsetInAncestryError, msg # we may require the machine to be set later # but for now, we can get the superdict with # an optional machine argument. # FIXME: we need to include families here. def get_superdict(self, machine=None): if machine is None: self._check_machine_set() machine = self.current_machine # childfirst is False because we go from top down # here, to get the child to override the parent parents = self.parents.get_parent_list(childfirst=False, machine=machine) superdict = dict() for parent in parents: parent_families = self.get_families(machine=parent) famdata = self.mainfamily.FamilyData(families=parent_families) superdict.update(famdata) superdict.update(self.environment.make_superdict(machine=parent)) families = self.get_families(machine=machine) famdata = self.mainfamily.FamilyData(families=families) superdict.update(famdata) superdict.update(self.environment.make_superdict(machine=machine)) return superdict def edit_variables(self, machine=None): if machine is None: self._check_machine_set() machine = self.current_machine config = MachineVariablesConfig(self.conn, machine) newconfig = config.edit() config.update(newconfig)
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) 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
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) self.current = None def delete_profile(self, profile): self.execute("select * from delete_profile('%s')" % profile) def make_new_profile(self, profile, suite): data = dict(profile=profile, suite=suite) self.insert(data=data) def make_environment_object(self): return ProfileEnvironment(self.conn) 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, traits, log=None): tp = TraitParent(self.conn, self.current.suite) listed = traits all = list(tp.get_traitset(listed)) setfun = tp.set_trait parfun = tp.parents return make_deplist(listed, all, setfun, parfun, log) def make_traitlist_with_traits(self, traits, log=None): return self._make_traitlist(traits, log=log) def make_traitlist(self, log=None): listed = [x.trait for x in self._traits.trait_rows()] return self._make_traitlist(listed, log=log) def get_traitlist_for_traits(self, traits): return self._make_traitlist(traits) 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)) if current is not None: self.set_profile(current.profile) 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 edit_variables(self): config = ProfileVariablesConfig(self.conn, self.current.profile) newconfig = config.edit() config.update(newconfig) def delete_trait(self, trait): self._traits.delete(trait) def delete_all_traits(self): self._traits.delete_all() def delete_family(self, family): clause = Eq('profile', self.current.profile) & Eq('family', family) self._pfam.delete(clause=clause) def delete_all_families(self): clause = Eq('profile', self.current.profile) self._pfam.delete(clause=clause) def insert_new_traits(self, traits): self.delete_all_traits() num = 0 for trait in traits: self.append_trait(trait, num) num += 1 def generate_xml(self, profile=None, suite=None, env=None): if profile is None: profile = self.current.profile suite = self.current.suite if suite is None: row = self.select_row(clause=Eq('profile', profile)) suite = row.suite if env is None: env = ProfileEnvironment(self.conn, profile) element = ProfileElement(profile, suite) element.append_traits(self._traits.trait_rows(profile)) element.append_families(self.family_rows(profile)) element.append_variables(env.get_rows()) return element def import_profile(self, filename): profile = parse_profile(filename) if profile.name in self.get_profile_list(): raise AlreadyExistsError, '%s already exists.' % profile.name self.insert(data=dict(profile=profile.name, suite=profile.suite)) # insert profile traits idata = dict(profile=profile.name, trait=None, ord=0) for trait, ord in profile.traits: idata['trait'] = trait idata['ord'] = ord self.insert(table='profile_trait', data=idata) # insert profile families idata = dict(profile=profile.name) for family in profile.families: idata['family'] = family self.insert(table='profile_family', data=idata) # insert profile variables idata = dict(profile=profile.name, trait=None, name=None, value=None) for trait, name, value in profile.vars: idata.update(dict(trait=trait, name=name, value=value)) self.insert(table='profile_variables', data=idata) def export_profile(self, dirname, profile=None, env=None): element = self.generate_xml(profile=profile, env=env) if profile is None: profile = self.current.profile filename = path(dirname) / ('%s.xml' % profile) element.writexml(filename.open('w'), indent='\t', newl='\n', addindent='\t') def import_all_profiles(self, dirname): dirname = path(dirname) files = [p for p in dirname.listdir() if p.endswith('.xml')] for filename in files: self.import_profile(filename) def export_all_profiles(self, dirname): for profile in self.get_profile_list(): self.export_profile(dirname, profile=profile)