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)
