class TraitAssigner(BaseAssigner):
def __init__(self, app, parent, profile):
self.profile = Profile(app.conn)
self.profile.set_profile(profile)
BaseAssigner.__init__(self, app, parent,
name='TraitAssigner', udbuttons=True)
self.connect(self, SIGNAL('okClicked()'), self.slotInsertNewTraits)
def initView(self):
app = self.app
self.db = app.db
self.suite = self.profile.current.suite
self.traits = StatementCursor(app.conn)
self.traits.set_table('%s_traits' % self.suite)
ptrows = self.profile.get_trait_rows()
pt = [r.trait for r in ptrows]
all_trows = self.traits.select(fields=['trait'], order=['trait'])
trows = [r for r in all_trows if r.trait not in pt]
abox = self.listBox.availableListBox()
sbox = self.listBox.selectedListBox()
for row in ptrows:
r = QListBoxText(sbox, row.trait)
r.trait = row.trait
for row in trows:
r = QListBoxText(abox, row.trait)
r.trait = row.trait
def slotInsertNewTraits(self):
sbox = self.listBox.selectedListBox()
traits = [sbox.item(n).trait for n in range(sbox.numRows())]
self.profile.insert_new_traits(traits)
class TraitAssigner(BaseAssigner):
def __init__(self, parent, profile):
self.app = get_application_pointer()
self.conn = self.app.conn
self.profile = Profile(self.conn)
self.profile.set_profile(profile)
BaseAssigner.__init__(self, parent, name="TraitAssigner", udbuttons=True)
self.connect(self, SIGNAL("okClicked()"), self.slotInsertNewTraits)
def initView(self):
self.suite = self.profile.current.suite
# self.traits is just a cursor
self.traits = self.conn.cursor(statement=True)
self.traits.set_table("%s_traits" % self.suite)
ptrows = self.profile.get_trait_rows()
pt = [row.trait for row in ptrows]
all_trows = self.traits.select(fields=["trait"], order=["trait"])
trows = [row for row in all_trows if row.trait not in pt]
abox = self.listBox.availableListBox()
sbox = self.listBox.selectedListBox()
for row in ptrows:
r = QListBoxText(sbox, row.trait)
for row in trows:
r = QListBoxText(abox, row.trait)
def slotInsertNewTraits(self):
sbox = self.listBox.selectedListBox()
traits = [str(sbox.item(n).text()) for n in range(sbox.numRows())]
self.profile.insert_new_traits(traits)
class ProfileDoc(BaseDocument):
def __init__(self, app, **atts):
BaseDocument.__init__(self, app, **atts)
self.profile = Profile(self.conn)
def set_profile(self, profile):
self.clear_body()
self.profile.set_profile(profile)
title = SimpleTitleElement('Profile: %s' % profile, bgcolor='IndianRed',
width='100%')
self.body.appendChild(title)
rows = self.profile.get_trait_rows()
ptitle = Anchor('edit.traits.%s' % self.profile.current.profile, 'Traits')
self.body.appendChild(SectionTitle(ptitle))
#self.body.appendChild(SectionTitle('Traits'))
if len(rows):
self.body.appendChild(TraitTable(rows, bgcolor='IndianRed1'))
vtitle = Anchor('edit.variables.%s' % self.profile.current.profile, 'Variables')
self.body.appendChild(SectionTitle(vtitle))
erows = self.profile._env.get_rows()
if len(erows):
self.body.appendChild(PVarTable(erows, bgcolor='MistyRose2'))
etitle = Anchor('edit.families.%s' % self.profile.current.profile, 'Families')
self.body.appendChild(SectionTitle(etitle))
families = self.profile.get_families()
flist = UnorderedList()
for f in families:
flist.appendChild(ListItem(f))
self.body.appendChild(flist)
class ToolkitDatabase(object):
def __init__(self, conn):
self.conn = conn
self.profile = Profile(self.conn)
self.family = Family(self.conn)
self.suite = None
self.trait = None
self.machine = MachineHandler(self.conn)
def set_profile(self, profile):
self.profile.set_profile(profile)
self.suite = self.profile.current.suite
self.trait = Trait(self.conn, self.suite)
def set_trait(self, trait):
self.trait.set_trait(trait)
def set_machine(self, machine):
self.machine.set_machine(machine)
profile = self.machine.get_profile()
self.set_profile(profile)
if os.environ.has_key('PAELLA_TRAIT'):
self.set_trait(os.environ['PAELLA_TRAIT'])
def env(self):
env = TemplatedEnvironment()
if self.trait.current_trait is not None:
env.update(self.trait._parents.Environment())
env.update(self.profile.get_family_data())
env.update(self.profile.get_profile_data())
if self.machine.current_machine is not None:
env.update(self.machine.get_machine_data())
return env
def __init__(self, conn, cfg):
os.environ['DEBIAN_FRONTEND'] = 'noninteractive'
Installer.__init__(self, conn, cfg)
self.profiletrait = ProfileTrait(self.conn)
self.profile = None
self.installer = None
self.cfg = cfg
self._profile = Profile(self.conn)
self.log.info('profile installer initialized')
def __init__(self, parent, profile):
self.app = get_application_pointer()
self.conn = self.app.conn
self.profile = Profile(self.conn)
self.profile.set_profile(profile)
BaseAssigner.__init__(self, parent, name="FamilyAssigner", udbuttons=True)
self.connect(self, SIGNAL("okClicked()"), self.slotInsertNewFamilies)
def __init__(self, parent):
BaseInstaller.__init__(self, parent.conn)
self._parent = parent
self.target = parent.target
# we need this paelladir attribute for now
# but may replace/redo this later
self.paelladir = self.target / 'root/paella'
self.profile = None
self.suite = None
self.profiletrait = ProfileTrait(self.conn)
self._profile = Profile(self.conn)
if False:
# setup logfile
if hasattr(parent, 'log'):
self.log = parent.log
self.log.info('profile installer initialized')
else:
raise RuntimeError, 'No logfile for parent defined'
if hasattr(parent, 'mainlog'):
self.mainlog = parent.mainlog
name = self.__class__.__name__
self.mainlog.add_logger(name)
self.log = self.mainlog.loggers[name]
# make empty data dicts
self.mtypedata = {}
self.familydata = {}
self.profiledata = {}
def __init__(self, conn):
self.conn = conn
self.profile = Profile(self.conn)
self.family = Family(self.conn)
self.suite = None
self.trait = None
self.machine = MachineHandler(self.conn)
def __init__(self):
object.__init__(self)
self.cfg = PaellaConfig()
self.conn = InstallerConnection()
self.profile = os.environ["PAELLA_PROFILE"]
self.target = path(os.environ["PAELLA_TARGET"])
self.machine = None
self.trait = None
self.suite = get_suite(self.conn, self.profile)
self.pr = Profile(self.conn)
self.pr.set_profile(self.profile)
self.traitlist = self.pr.make_traitlist()
self.pe = ProfileEnvironment(self.conn, self.profile)
self.tp = TraitParent(self.conn, self.suite)
self.fm = Family(self.conn)
self.tr = Trait(self.conn, self.suite)
self.families = list(self.fm.get_related_families(self.pr.get_families()))
self._envv = None
self.default = DefaultEnvironment(self.conn)
# self.installer = TraitInstaller(self.conn, self.suite)
self.installer = ProfileInstaller(self.conn)
self.installer.set_logfile()
self.installer.set_profile(self.profile)
self.installer.set_target(self.target)
if os.environ.has_key("PAELLA_MACHINE"):
self.machine = os.environ["PAELLA_MACHINE"]
if os.environ.has_key("PAELLA_TRAIT"):
self.set_trait(os.environ["PAELLA_TRAIT"])
def __init__(self, parent, profile):
self.app = get_application_pointer()
self.conn = self.app.conn
self.profile = Profile(self.conn)
self.profile.set_profile(profile)
BaseAssigner.__init__(self, parent, name='TraitAssigner',
udbuttons=True)
self.connect(self, SIGNAL('okClicked()'), self.slotInsertNewTraits)
class FamilyAssigner(BaseAssigner):
def __init__(self, parent, profile):
self.app = get_application_pointer()
self.conn = self.app.conn
self.profile = Profile(self.conn)
self.profile.set_profile(profile)
BaseAssigner.__init__(self, parent, name="FamilyAssigner", udbuttons=True)
self.connect(self, SIGNAL("okClicked()"), self.slotInsertNewFamilies)
def initView(self):
self.suite = self.profile.current.suite
self.family = Family(self.conn)
all_fams = self.family.all_families()
pfams = self.profile.get_families()
fams = [f for f in all_fams if f not in pfams]
abox = self.listBox.availableListBox()
sbox = self.listBox.selectedListBox()
for family in pfams:
self._add_family_to_listbox(sbox, family)
for family in fams:
self._add_family_to_listbox(abox, family)
def _add_family_to_listbox(self, box, family):
r = QListBoxText(box, family)
r.family = family
def slotInsertNewFamilies(self):
sbox = self.listBox.selectedListBox()
families = [str(sbox.item(n).text()) for n in range(sbox.numRows())]
self.profile.delete_all_families()
for family in families:
self.profile.append_family(family)
def __init__(self, conn, cfg):
os.environ['DEBIAN_FRONTEND'] = 'noninteractive'
Installer.__init__(self, conn, cfg)
self.profiletrait = ProfileTrait(self.conn)
self.profile = None
self.installer = None
self.cfg = cfg
self._profile = Profile(self.conn)
self.log.info('profile installer initialized')
def create_profile(self, button):
name = button.get_name()
debug(name)
if name == 'create':
profile = self.dialogs[name].get()
self.destroy_dialog(self.dialogs[name])
profiles = [p.profile for p in self.profiles.select()]
if profile not in profiles:
skel_profile = self.cfg.get('management_gui', 'template_profile')
if skel_profile in profiles:
p = Profile(self.conn)
p.set_profile(skel_profile)
p.copy_profile(skel_profile, profile)
else:
suite = self.cfg.get('management_gui', 'default_profile_suite')
self.profiles.insert(data={'profile' : profile,
'suite' : suite})
self.browser.reset_rows()
else:
dialogs.Dialog('there was a problem')
def __init__(self, conn):
os.environ['DEBIAN_FRONTEND'] = 'noninteractive'
Installer.__init__(self, conn)
self.profiletrait = ProfileTrait(self.conn)
self.profile = None
self.installer = None
self._profile = Profile(self.conn)
if hasattr(self, 'log'):
self.log.info('profile installer initialized')
else:
self.set_logfile()
self.log.info('profile installer initialized')
self.mtypedata = {}
class ProfileDoc(BaseDocument):
def __init__(self, app, **atts):
BaseDocument.__init__(self, app, **atts)
self.profile = Profile(self.conn)
def set_profile(self, profile):
self.clear_body()
self.profile.set_profile(profile)
suite = self.profile.current.suite
maintitle_text = 'Profile: %s' % profile
#ptitle.append('(suite ')
#ptitle.append(Anchor(suite, href='change.suite.%s' % suite))
#ptitle.append(')')
#title = SectionTitle('Profile: %s (suite %s) ' % (profile, suite))
title = SectionTitle(maintitle_text)
title['bgcolor'] = 'IndianRed'
title['width'] = '100%'
title.cell.append(' (suite ')
title.cell.append(Anchor(suite, href='change.suite.%s' % suite))
title.cell.append(')')
self.body.append(title)
rows = self.profile.get_trait_rows()
ptitle = Anchor('Traits', href='edit.traits.%s' % self.profile.current.profile)
self.body.append(SectionTitle(ptitle))
if len(rows):
self.body.append(TraitTable(rows, bgcolor='IndianRed1'))
vtitle = Anchor('Variables', href='edit.variables.%s' % self.profile.current.profile)
self.body.append(SectionTitle(vtitle))
erows = self.profile._env.get_rows()
if len(erows):
self.body.append(PVarTable(erows, bgcolor='MistyRose2'))
etitle = Anchor('Families', href='edit.families.%s' % self.profile.current.profile)
self.body.append(SectionTitle(etitle))
families = self.profile.get_families()
flist = UnorderedList()
for f in families:
flist.append(ListItem(f))
self.body.append(flist)
def __init__(self, app, parent):
SimpleSplitWindow.__init__(self, app, parent, ProfileView, 'ProfileMainWindow')
self.app = app
self.initActions()
self.initMenus()
self.initToolbar()
self.conn = app.conn
self.cfg = app.cfg
self.cursor = StatementCursor(self.conn)
self.profile = Profile(self.conn)
self.refreshListView()
self.resize(600, 800)
self.setCaption('paella profiles')
def __init__(self, parent):
BaseSplitWindow.__init__(self, parent, ProfileView, name="ProfileMainWindow")
self.initPaellaCommon()
self.initActions()
self.initMenus()
self.initToolbar()
self.cursor = self.conn.cursor(statement=True)
self.profile = Profile(self.conn)
self.refreshListView()
self.resize(600, 800)
self.splitter.setSizes([150, 450])
self.setCaption("Paella Profiles")
self._dialog = None
self.connect(self.mainView, PYSIGNAL("changeSuite"), self.slotChangeSuite)
def __init__(self, conn, suites, name='ProfileBrowser'):
self.menu = self.__make_mainmenu_(suites)
ListNoteBook.__init__(self, name=name)
self.conn = conn
self.profiles = Profile(self.conn)
self.profiletrait = ProfileTrait(self.conn)
self.family = Family(self.conn)
self.pfamily = StatementCursor(self.conn)
self.pfamily.set_table('profile_family')
self.trait_menu = make_menu(['drop', 'order'], self.trait_command)
self.pdata_menu = make_menu(['edit', 'drop'], self.variable_command)
self.family_menu = make_menu(['drop'], self.family_command)
self.reset_rows()
self.append_page(ScrollCList(rcmenu=self.trait_menu), 'traits')
self.append_page(ScrollCList(rcmenu=self.pdata_menu), 'variables')
self.append_page(ScrollCList(rcmenu=self.family_menu), 'families')
self.dialogs = {}.fromkeys(['order'])
def __init__(self, parent):
BaseInstaller.__init__(self, parent.conn)
self._parent = parent
self.target = parent.target
# we need this paelladir attribute for now
# but may replace/redo this later
self.paelladir = self.target / 'root/paella'
self.profile = None
self.suite = None
self.profiletrait = ProfileTrait(self.conn)
self._profile = Profile(self.conn)
if hasattr(parent, 'mainlog'):
self.mainlog = parent.mainlog
name = self.__class__.__name__
self.mainlog.add_logger(name)
self.log = self.mainlog.loggers[name]
# make empty data dicts
self.machine_data = {}
self.familydata = {}
self.profiledata = {}
class ProfileInstaller(Installer):
def __init__(self, conn, cfg):
os.environ['DEBIAN_FRONTEND'] = 'noninteractive'
Installer.__init__(self, conn, cfg)
self.profiletrait = ProfileTrait(self.conn)
self.profile = None
self.installer = None
self.cfg = cfg
self._profile = Profile(self.conn)
self.log.info('profile installer initialized')
def set_profile(self, profile):
self.profile = profile
self._profile.set_profile(profile)
os.environ['PAELLA_PROFILE'] = profile
self.profiletrait.set_profile(profile)
self.traits = self.profiletrait.trait_rows()
self.env = ProfileEnvironment(self.conn, self.profile)
self.familydata = self._profile.get_family_data()
self.profiledata = self._profile.get_profile_data()
self.suite = get_suite(self.conn, profile)
self.installer = TraitInstaller(self.conn, self.suite, self.cfg)
self.installer.log = self.log
self.installer.familydata = self.familydata
self.installer.profiledata = self.profiledata
self.traitparent = TraitParent(self.conn, self.suite)
self.log.info('profile set to %s' % profile)
def get_profile_data(self):
return self.env.ProfileData()
def set_logpath(self, logpath):
Installer.set_logpath(self, logpath)
if hasattr(self, 'installer'):
self.installer.set_logpath(logpath)
def make_traitlist(self):
tp = TraitParent(self.conn, self.suite)
listed = [x.trait for x in self.profiletrait.trait_rows()]
all = list(self.traitparent.get_traitset(listed))
setfun = tp.set_trait
parfun = tp.parents
log = self.log
return make_deplist(listed, all, setfun, parfun, log)
def setup_initial_paellainfo_files(self, traits):
makepaths(self.paelladir)
traitlist = file(join(self.paelladir, 'traitlist'), 'w')
for trait in traits:
traitlist.write('%s\n' % trait)
traitlist.close()
itraits = file(join(self.paelladir, 'installed_traits'), 'w')
itraits.write('Installed Traits:\n')
itraits.close()
def process(self):
traits = self.make_traitlist()
self.setup_initial_paellainfo_files(traits)
self.processed = []
for trait in traits:
self.process_trait(trait)
self.log.info('currently processed %s' % ','.join(self.processed))
self.log.info('all traits processed for profile %s' % self.profile)
self.log.info('------------------------------------')
def _append_installed_traits_file(self, trait):
itraits = file(join(self.paelladir, 'installed_traits'), 'a')
itraits.write(trait + '\n')
itraits.close()
def process_trait(self, trait):
self.traitparent.set_trait(trait)
self.installer.set_trait(trait)
parents = [r.parent for r in self.traitparent.parents()]
for p in parents:
if p not in self.processed:
raise UnbornError
self.log.info('processing trait %s' % trait)
self.installer.process()
self.processed.append(trait)
self.log.info('processed: %s' % ', '.join(self.processed))
self._append_installed_traits_file(trait)
def set_template_path(self, path):
self.installer.set_template_path(path)
def set_target(self, target, update=False):
Installer.set_target(self, target)
self.installer.set_target(target)
if update:
os.system(self.command('apt-get update'))
def install_kernel(self, package):
os.system(self.command('touch /boot/vmlinuz-fake'))
os.system(self.command('ln -s boot/vmlinuz-fake vmlinuz'))
os.system(self.command('apt-get -y install %s' % package))
print 'kernel %s installed' % package
class ProfileMainWindow(SimpleSplitWindow):
def __init__(self, app, parent):
SimpleSplitWindow.__init__(self, app, parent, ProfileView, 'ProfileMainWindow')
self.app = app
self.initActions()
self.initMenus()
self.initToolbar()
self.conn = app.conn
self.cfg = app.cfg
self.cursor = StatementCursor(self.conn)
self.profile = Profile(self.conn)
self.refreshListView()
self.resize(600, 800)
self.setCaption('paella profiles')
def initActions(self):
collection = self.actionCollection()
self.quitAction = KStdAction.quit(self.close, collection)
self.newProfileAction = KStdAction.openNew(self.newProfile, collection)
def initMenus(self):
mainMenu = KPopupMenu(self)
menus = [mainMenu]
self.menuBar().insertItem('&Main', mainMenu)
self.menuBar().insertItem('&Help', self.helpMenu(''))
self.newProfileAction.plug(mainMenu)
self.quitAction.plug(mainMenu)
def initToolbar(self):
toolbar = self.toolBar()
self.newProfileAction.plug(toolbar)
self.quitAction.plug(toolbar)
def initlistView(self):
self.listView.setRootIsDecorated(True)
self.listView.addColumn('group')
def refreshListView(self):
self.listView.clear()
for row in self.profile.select(fields=['profile', 'suite'], order='profile'):
item = KListViewItem(self.listView, row.profile)
item.profile = row.profile
def newProfile(self):
dialog = SimpleRecordDialog(self, ['profile'])
dialog.connect(dialog, SIGNAL('okClicked()'), self.insertNewProfile)
self._dialog = dialog
def insertNewProfile(self):
dialog = self._dialog
data = dialog.getRecordData()
if data['profile'] not in self.profile.get_profile_list():
#self.profile.insert(data=data)
self.profile.copy_profile('skeleton', data['profile'])
else:
KMessageBox.information(self, 'profile %s already exists.' % data['profile'])
#KMessageBox.information(self, 'Make new profile %s' % data['profile'])
self.refreshListView()
def selectionChanged(self):
current = self.listView.currentItem()
if hasattr(current, 'profile'):
self.view.set_profile(current.profile)
if hasattr(current, 'trait'):
print 'trait is', current.trait
self.view.set_trait(current.trait)
if hasattr(current, 'suite'):
print 'suite is', current.suite
if hasattr(current, 'widget'):
print 'widget is', current.widget
def resetProfileObject(self):
self.profile = Profile(self.conn)
def __init__(self, app, parent, profile):
self.profile = Profile(app.conn)
self.profile.set_profile(profile)
BaseAssigner.__init__(self, app, parent,
name='FamilyAssigner', udbuttons=True)
self.connect(self, SIGNAL('okClicked()'), self.slotInsertNewFamilies)
def __init__(self, app, **atts):
BaseDocument.__init__(self, app, **atts)
self.profile = Profile(self.conn)
class ProfileMainWindow(BaseSplitWindow, BasePaellaWindow):
def __init__(self, parent):
BaseSplitWindow.__init__(self, parent, ProfileView, name="ProfileMainWindow")
self.initPaellaCommon()
self.initActions()
self.initMenus()
self.initToolbar()
self.cursor = self.conn.cursor(statement=True)
self.profile = Profile(self.conn)
self.refreshListView()
self.resize(600, 800)
self.splitter.setSizes([150, 450])
self.setCaption("Paella Profiles")
self._dialog = None
self.connect(self.mainView, PYSIGNAL("changeSuite"), self.slotChangeSuite)
def initActions(self):
collection = self.actionCollection()
self.quitAction = KStdAction.quit(self.close, collection)
self.newProfileAction = KStdAction.openNew(self.newProfile, collection)
self.importProfileAction = KStdAction.open(self.slotImportProfile, collection)
self.exportProfileAction = KStdAction.saveAs(self.slotExportProfile, collection)
def initMenus(self):
mainmenu = KPopupMenu(self)
menubar = self.menuBar()
menubar.insertItem("&Main", mainmenu)
menubar.insertItem("&Help", self.helpMenu(""))
self.newProfileAction.plug(mainmenu)
self.importProfileAction.plug(mainmenu)
self.exportProfileAction.plug(mainmenu)
self.quitAction.plug(mainmenu)
def initToolbar(self):
toolbar = self.toolBar()
self.newProfileAction.plug(toolbar)
self.importProfileAction.plug(toolbar)
self.exportProfileAction.plug(toolbar)
self.quitAction.plug(toolbar)
def initlistView(self):
self.listView.setRootIsDecorated(False)
self.listView.addColumn("profile")
self.listView.addColumn("suite")
def refreshListView(self):
self.listView.clear()
for row in self.profile.select(fields=["profile", "suite"], order=["profile"]):
item = KListViewItem(self.listView, row.profile, row.suite)
item.profile = row.profile
def newProfile(self):
win = BaseRecordDialog(self, ["name"])
win.frame.text_label.setText("Name for new profile:")
win.connect(win, SIGNAL("okClicked()"), self.insertNewProfile)
skeleton = self.cfg.get("management_gui", "template_profile")
if skeleton not in self.profile.get_profile_list():
msg = "Name for new profile: (skeleton does not exist yet.)"
win.frame.text_label.setText(msg)
win.setRecordData(dict(name=skeleton))
win.show()
self._dialog = win
def insertNewProfile(self):
win = self._dialog
profile = win.getRecordData()["name"]
profile_list = self.profile.get_profile_list()
if profile not in profile_list:
skeleton = self.cfg.get("management_gui", "template_profile")
if skeleton in profile_list:
self.profile.copy_profile(skeleton, profile)
self.refreshListView()
else:
dlg = BaseRecordDialog(win, ["suite"])
dlg.frame.text_label.setText("Select a suite for this profile")
dlg.connect(dlg, SIGNAL("okClicked()"), self.insertNewProfilewithSuite)
dlg.show()
dlg.profile = profile
win.suite_dialog = dlg
KMessageBox.information(self, "need to select suite here")
# need to determine if skeleton exists
KMessageBox.information(self, "make profile %s" % profile)
else:
KMessageBox.error(self, "Profile %s already exists." % profile)
def insertNewProfilewithSuite(self):
win = self._dialog.suite_dialog
profile = win.profile
suite = win.getRecordData()["suite"]
self.profile.make_new_profile(profile, suite)
self._dialog = None
self.refreshListView()
def selectionChanged(self):
item = self.listView.currentItem()
self.mainView.set_profile(item.profile)
self.profile.set_profile(item.profile)
def slotChangeSuite(self):
win = SuiteSelectDialog(self)
win.connect(win, SIGNAL("okClicked()"), self.slotSuiteSelected)
win.show()
self._dialog = win
def slotSuiteSelected(self):
win = self._dialog
suite = str(win.suite.currentText())
KMessageBox.information(self, "change to suite %s" % suite)
if suite != self.profile.current.suite:
self.profile.set_suite(suite)
self.mainView.resetView()
def slotImportProfile(self):
KMessageBox.information(self, "Import unimplemented")
def slotExportProfile(self):
KMessageBox.information(self, "Export unimplemented")
def resetProfileObject(self):
self.profile = Profile(self.conn)
class ProfileInstaller(Installer):
def __init__(self, conn):
os.environ['DEBIAN_FRONTEND'] = 'noninteractive'
Installer.__init__(self, conn)
self.profiletrait = ProfileTrait(self.conn)
self.profile = None
self.installer = None
self._profile = Profile(self.conn)
if hasattr(self, 'log'):
self.log.info('profile installer initialized')
else:
self.set_logfile()
self.log.info('profile installer initialized')
self.mtypedata = {}
def set_profile(self, profile):
self.profile = profile
self._profile.set_profile(profile)
os.environ['PAELLA_PROFILE'] = profile
self.profiletrait.set_profile(profile)
self.traits = self.profiletrait.trait_rows()
self.env = ProfileEnvironment(self.conn, self.profile)
self.familydata = self._profile.get_family_data()
self.profiledata = self._profile.get_profile_data()
self.suite = get_suite(self.conn, profile)
self.installer = TraitInstaller(self.conn, self.suite)
self.installer.log = self.log
self.installer.familydata = self.familydata
self.installer.profiledata = self.profiledata
self.installer.mtypedata = self.mtypedata
self.traitparent = TraitParent(self.conn, self.suite)
self.log.info('profile set to %s' % profile)
traitlist = self.make_traitlist()
self.setup_initial_paellainfo_env(traitlist)
def get_profile_data(self):
return self.env.ProfileData()
def set_logpath(self, logpath):
Installer.set_logpath(self, logpath)
if hasattr(self, 'installer'):
self.installer.set_logpath(logpath)
def make_traitlist(self):
listed = [x.trait for x in self.profiletrait.trait_rows()]
#log = self.log
log = None
return self._profile.make_traitlist_with_traits(listed, log=log)
def setup_initial_paellainfo_files(self, traits):
makepaths(self.paelladir)
traitlist = file(join(self.paelladir, 'traitlist'), 'w')
for trait in traits:
traitlist.write('%s\n' % trait)
traitlist.close()
itraits = file(join(self.paelladir, 'installed_traits'), 'w')
itraits.write('Installed Traits:\n')
itraits.close()
def setup_initial_paellainfo_env(self, traits):
if os.environ.has_key('PAELLA_MACHINE'):
machine = os.environ['PAELLA_MACHINE']
curenv = CurrentEnvironment(self.conn, machine)
curenv['current_profile'] = self.profile
curenv['traitlist'] = ', '.join(traits)
curenv['installed_traits'] = ''
def process(self):
traits = self.make_traitlist()
self.setup_initial_paellainfo_files(traits)
self.setup_initial_paellainfo_env(traits)
self.processed = []
for trait in traits:
self.process_trait(trait)
self.log.info('currently processed %s' % ','.join(self.processed))
self.log.info('all traits processed for profile %s' % self.profile)
self.log.info('------------------------------------')
def _append_installed_traits_file(self, trait):
itraits = file(join(self.paelladir, 'installed_traits'), 'a')
itraits.write(trait + '\n')
itraits.close()
def _append_installed_traits_db(self, trait):
if os.environ.has_key('PAELLA_MACHINE'):
machine = os.environ['PAELLA_MACHINE']
curenv = CurrentEnvironment(self.conn, machine)
line = curenv['installed_traits']
traits = [t.strip() for t in line.split(',')]
traits.append(trait)
curenv['installed_traits'] = ', '.join(traits)
def process_trait(self, trait):
self.traitparent.set_trait(trait)
self.installer.set_trait(trait)
parents = [r.parent for r in self.traitparent.parents()]
for p in parents:
if p not in self.processed:
raise UnbornError
self.log.info('processing trait %s' % trait)
self.installer.process()
self.processed.append(trait)
self.log.info('processed: %s' % ', '.join(self.processed))
self.append_installed_traits(trait)
def set_template_path(self, path):
self.installer.set_template_path(path)
def set_target(self, target, update=False):
Installer.set_target(self, target)
self.installer.set_target(target)
if update:
os.system(self.command('apt-get update'))
def install_kernel(self, package):
os.system(self.command('touch /boot/vmlinuz-fake'))
os.system(self.command('ln -s boot/vmlinuz-fake vmlinuz'))
os.system(self.command('apt-get -y install %s' % package))
print 'kernel %s installed' % package
def append_installed_traits(self, trait):
self._append_installed_traits_file(trait)
self._append_installed_traits_db(trait)
class ProfileInstaller(BaseInstaller):
# here parent is the chroot installer
# The target needs to be set in the parent before
# this class is initialized.
def __init__(self, parent):
BaseInstaller.__init__(self, parent.conn)
self._parent = parent
self.target = parent.target
# we need this paelladir attribute for now
# but may replace/redo this later
self.paelladir = self.target / 'root/paella'
self.profile = None
self.suite = None
self.profiletrait = ProfileTrait(self.conn)
self._profile = Profile(self.conn)
if False:
# setup logfile
if hasattr(parent, 'log'):
self.log = parent.log
self.log.info('profile installer initialized')
else:
raise RuntimeError, 'No logfile for parent defined'
if hasattr(parent, 'mainlog'):
self.mainlog = parent.mainlog
name = self.__class__.__name__
self.mainlog.add_logger(name)
self.log = self.mainlog.loggers[name]
# make empty data dicts
self.mtypedata = {}
self.familydata = {}
self.profiledata = {}
# this method is called within set_profile
def _init_attributes(self):
self.traits = self.profiletrait.trait_rows()
self.env = ProfileEnvironment(self.conn, self.profile)
self.familydata = self._profile.get_family_data()
self.profiledata = self._profile.get_profile_data()
self.suite = get_suite(self.conn, self.profile)
# this method is called within set_profile
# here is where the trait installer is setup
# the data attributes need to be filled before this is called
# this method needs to be fixed to use the new trait installer
def _setup_installer(self, suite):
self.installer = TraitInstaller(self)
self.installer.familydata = self.familydata
self.installer.profiledata = self.profiledata
self.installer.mtypedata = self.mtypedata
# here is where the processes are setup
# every process is a trait and it maps to the same
# function. a "current_index" attribute keeps track
# of which trait is being processed.
def _setup_trait_processes(self, traitlist):
self.setup_initial_paellainfo_env(traitlist)
self._processes = traitlist
self._process_map = {}.fromkeys(traitlist, self.process_trait)
# setting the profile involves a lot of work
# there are helper methods defined to help split
# the code up into more manageable pieces.
def set_profile(self, profile):
self.profile = profile
self._profile.set_profile(profile)
os.environ['PAELLA_PROFILE'] = profile
self.profiletrait.set_profile(profile)
self._init_attributes()
self._setup_installer(self.suite)
self.traitparent = TraitParent(self.conn, self.suite)
self.log.info('profile set to %s' % profile)
traitlist = self.make_traitlist()
self._setup_trait_processes(traitlist)
# currently there is no script functionality
# but there may be in the future.
def make_script(self, procname):
return None
# this method needs to be checked
def make_traitlist(self):
listed = [x.trait for x in self.profiletrait.trait_rows()]
log = None
return self._profile.make_traitlist_with_traits(listed, log=log)
def get_profile_data(self):
return self.env.ProfileData()
# this method needs to be checked
# self.paelladir needs to be defined
def setup_initial_paellainfo_files(self, traits):
makepaths(self.paelladir)
traitlist = file(join(self.paelladir, 'traitlist'), 'w')
for trait in traits:
traitlist.write('%s\n' % trait)
traitlist.close()
itraits = file(join(self.paelladir, 'installed_traits'), 'w')
itraits.write('Installed Traits:\n')
itraits.close()
# initialize data in current_environment,
# if PAELLA_MACHINE is set
def setup_initial_paellainfo_env(self, traits):
if os.environ.has_key('PAELLA_MACHINE'):
machine = os.environ['PAELLA_MACHINE']
curenv = CurrentEnvironment(self.conn, machine)
curenv['current_profile'] = self.profile
curenv['traitlist'] = ', '.join(traits)
curenv['installed_traits'] = ''
# this method has been rewritten to use
# self.current_index
# the UnbornError should never be raised
def process_trait(self):
trait = self._processes[self.current_index]
self.traitparent.set_trait(trait)
self.installer.set_trait(trait)
parents = [r.parent for r in self.traitparent.parents()]
for p in parents:
if p not in self.processed:
raise UnbornError
self.log.info('processing trait %s' % trait)
self.installer.run_all_processes()
self.processed.append(trait)
self.current_index += 1
self.log.info('processed: %s' % ', '.join(self.processed))
self.append_installed_traits(trait)
# this used to be called process
def run_all_processes(self):
traits = self.make_traitlist()
self.setup_initial_paellainfo_files(traits)
self.setup_initial_paellainfo_env(traits)
self.processed = []
self.current_index = 0
BaseInstaller.run_all_processes(self)
self.log.info('all traits processed for profile %s' % self.profile)
self.log.info('------------------------------------')
# this method needs to be checked
def set_template_path(self, tpath):
self.installer.set_template_path(tpath)
# this method needs to be checked
# target should be set upon init.
# need to remove apt-get update command
def set_target(self, target, update=False):
Installer.set_target(self, target)
self.installer.set_target(target)
if update:
os.system(self.command('apt-get update'))
# this method needs to be checked
# this method doesn't belong in the profile installer
# this is a machine installer method
def install_kernel(self, package):
os.system(self.command('touch /boot/vmlinuz-fake'))
os.system(self.command('ln -s boot/vmlinuz-fake vmlinuz'))
os.system(self.command('apt-get -y install %s' % package))
print 'kernel %s installed' % package
# This helps reporting when when a trait is processed
def append_installed_traits(self, trait):
self._append_installed_traits_file(trait)
self._append_installed_traits_db(trait)
# this method needs to be checked
# self.paelladir needs to be defined
def _append_installed_traits_file(self, trait):
itraits = file(join(self.paelladir, 'installed_traits'), 'a')
itraits.write(trait + '\n')
itraits.close()
# this method needs to be checked
def _append_installed_traits_db(self, trait):
if os.environ.has_key('PAELLA_MACHINE'):
machine = os.environ['PAELLA_MACHINE']
curenv = CurrentEnvironment(self.conn, machine)
line = curenv['installed_traits']
traits = [t.strip() for t in line.split(',')]
traits.append(trait)
curenv['installed_traits'] = ', '.join(traits)
class ProfileBrowser(ListNoteBook, HasDialogs):
def __init__(self, conn, suites, name='ProfileBrowser'):
self.menu = self.__make_mainmenu_(suites)
ListNoteBook.__init__(self, name=name)
self.conn = conn
self.profiles = Profile(self.conn)
self.profiletrait = ProfileTrait(self.conn)
self.family = Family(self.conn)
self.pfamily = StatementCursor(self.conn)
self.pfamily.set_table('profile_family')
self.trait_menu = make_menu(['drop', 'order'], self.trait_command)
self.pdata_menu = make_menu(['edit', 'drop'], self.variable_command)
self.family_menu = make_menu(['drop'], self.family_command)
self.reset_rows()
self.append_page(ScrollCList(rcmenu=self.trait_menu), 'traits')
self.append_page(ScrollCList(rcmenu=self.pdata_menu), 'variables')
self.append_page(ScrollCList(rcmenu=self.family_menu), 'families')
self.dialogs = {}.fromkeys(['order'])
def __make_mainmenu_(self, suites):
suite_commands = ['change to %s' %suite for suite in suites]
profile_commands = ['drop', 'set defaults', 'append defaults']
commands = suite_commands + profile_commands
return make_menu(commands, self.profile_command)
def reset_rows(self):
self.set_rows(self.profiles.select(fields=['profile', 'suite'], order='profile'))
self.set_row_select(self.profile_selected)
def profile_selected(self, listbox, row, column, event):
row = listbox.get_selected_data()[0]
self.current = row
self.select_profile(self.current.profile)
def select_profile(self, profile):
self.variables = ProfileEnvironment(self.conn, profile)
self.profiletrait.set_profile(profile)
self.__set_pages(profile)
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')
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')
pfrows = self.pfamily.select(fields=['family'], clause=clause)
pages['families'].set_rows(pfrows)
pages['families'].set_select_mode('multi')
self.__set_droptargets__(pages)
def __set_droptargets__(self, pages):
set_receive_targets(pages['traits'].listbox,
self.drop_trait, TARGETS.get('trait', self.current.suite))
set_receive_targets(pages['families'].listbox,
self.drop_families, FTargets.get('family', 'flavor'))
def trait_command(self, menuitem, action):
traits = self._get_listbox('traits', 'trait')
if action == 'drop':
clause = In('trait', traits) & Eq('profile', self.current.profile)
self.profiletrait.cmd.delete(clause=clause)
self.__set_pages(self.current.profile)
elif action == 'order':
if not self.dialogs['order']:
self.dialogs['order'] = dialogs.Entry('enter order', name='order')
self.dialogs['order'].set_ok(self.set_order)
self.dialogs['order'].set_cancel(self.destroy_dialog)
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 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 edit_profilevars(self):
config = ProfileVariablesConfig(self.conn, self.current.profile)
newconfig = config.edit()
config.update(newconfig)
self.select_profile(self.current.profile)
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_trait(self, listbox, context, x, y, selection,
targettype, time):
traits = keysplitter(selection)
self.profiletrait.insert_traits(traits)
self.__set_pages(self.current.profile)
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 _get_listbox(self, page, field):
pages = dict(self.pages)
return [row[field] for row in pages[page].listbox.get_selected_data()]
def profile_command(self, menu, command):
if command[:10] == 'change to ':
self.change_suite(command[10:])
elif command == 'drop':
self.profiletrait.drop_profile(self.current.profile)
self.profiles.drop_profile(self.current.profile)
self.current = None
self.reset_rows()
elif command == 'set defaults':
self.variables.set_defaults()
elif command == 'append defaults':
self.variables.append_defaults()
else:
raise Error, 'bad command %s' %command
def change_suite(self, suite):
clause = Eq('profile', self.current.profile)
self.profiles.update(data={'suite' : suite}, clause=clause)
print 'changing suite to ', suite
self.current_suite = suite
self.reset_rows()
class InstallerTools(object):
def __init__(self):
object.__init__(self)
self.cfg = PaellaConfig()
self.conn = PaellaConnection()
self.profile = os.environ['PAELLA_PROFILE']
self.target = os.environ['PAELLA_TARGET']
self.machine = None
self.trait = None
self.suite = get_suite(self.conn, self.profile)
self.pr = Profile(self.conn)
self.pr.set_profile(self.profile)
self.traitlist = self.pr.make_traitlist()
self.pe = ProfileEnvironment(self.conn, self.profile)
self.tp = TraitParent(self.conn, self.suite)
self.fm = Family(self.conn)
self.tr = Trait(self.conn, self.suite)
self.families = list(self.fm.get_related_families(self.pr.get_families()))
self._envv = None
self.default = DefaultEnvironment(self.conn)
self.installer = TraitInstaller(self.conn, self.suite, self.cfg)
if os.environ.has_key('PAELLA_MACHINE'):
self.machine = os.environ['PAELLA_MACHINE']
if os.environ.has_key('PAELLA_TRAIT'):
self.set_trait(os.environ['PAELLA_TRAIT'])
def env(self):
env = RefDict(self.tp.Environment())
env.update(self.pr.get_family_data())
env.update(self.pr.get_profile_data())
return env
def set_trait(self, trait):
self.trait = trait
self.tp.set_trait(trait)
self.tr.set_trait(trait)
self.parents = self.tr.parents()
self._envv = self.env()
self.installer.set_trait(trait)
self.packages = self.installer.traitpackage.packages()
self.templates = self.installer.traittemplate.templates()
def get(self, key):
if self._envv is None:
raise Error, 'need to set trait first'
return self._envv.dereference(key)
def install_modules(self, name):
modules = str2list(self.get(name))
print 'installing modules', modules, 'to %s/etc/modules' % self.target
setup_modules(self.target, modules)
def remove_packages(self, packages=None):
if packages is None:
packages = self.packages
if len(packages):
if hasattr(packages[0], 'package'):
packages = [p.package for p in packages]
package_list = ' '.join(packages)
command = 'apt-get -y remove %s' % package_list
self.installer.run('remove', command, proc=True)
class InstallerTools(object):
def __init__(self):
object.__init__(self)
self.cfg = PaellaConfig()
self.conn = InstallerConnection()
self.profile = os.environ["PAELLA_PROFILE"]
self.target = path(os.environ["PAELLA_TARGET"])
self.machine = None
self.trait = None
self.suite = get_suite(self.conn, self.profile)
self.pr = Profile(self.conn)
self.pr.set_profile(self.profile)
self.traitlist = self.pr.make_traitlist()
self.pe = ProfileEnvironment(self.conn, self.profile)
self.tp = TraitParent(self.conn, self.suite)
self.fm = Family(self.conn)
self.tr = Trait(self.conn, self.suite)
self.families = list(self.fm.get_related_families(self.pr.get_families()))
self._envv = None
self.default = DefaultEnvironment(self.conn)
# self.installer = TraitInstaller(self.conn, self.suite)
self.installer = ProfileInstaller(self.conn)
self.installer.set_logfile()
self.installer.set_profile(self.profile)
self.installer.set_target(self.target)
if os.environ.has_key("PAELLA_MACHINE"):
self.machine = os.environ["PAELLA_MACHINE"]
if os.environ.has_key("PAELLA_TRAIT"):
self.set_trait(os.environ["PAELLA_TRAIT"])
# this needs updating for machine type data
def env(self):
env = TemplatedEnvironment(self.tp.Environment())
env.update(self.pr.get_family_data())
env.update(self.pr.get_profile_data())
return env
def set_trait(self, trait):
self.trait = trait
self.tp.set_trait(trait)
self.tr.set_trait(trait)
self.parents = self.tr.parents()
self._envv = self.env()
tinstaller = self.installer.installer
tinstaller.set_trait(trait)
self.packages = tinstaller.traitpackage.packages()
self.templates = tinstaller.traittemplate.templates()
def get(self, key):
if self._envv is None:
raise Error, "need to set trait first"
return self._envv.dereference(key)
def lget(self, key):
key = "_".join([self.trait, key])
return self.get(key)
def install_modules(self, name):
modules = str2list(self.get(name))
print "installing modules", modules, "to %s/etc/modules" % self.target
setup_modules(self.target, modules)
def remove_packages(self, packages=None):
if packages is None:
packages = self.packages
if len(packages):
if hasattr(packages[0], "package"):
packages = [p.package for p in packages]
package_list = " ".join(packages)
command = "apt-get -y remove %s" % package_list
self.installer.run("remove", command, proc=True)
def chroot_command(self, cmd):
return "chroot %s %s" % (self.target, cmd)
