def install_packages_uml(conn, suite, profile, target):
traits = get_traits(conn, profile)
tp = TraitParent(conn, suite)
pp = TraitPackage(conn, suite)
packages = ' '.join([p.package for p in pp.all_packages(traits, tp)])
os.system('chroot %s apt-get update' % target)
os.system('chroot %s apt-get -y install %s' % (target, packages))
def install_packages_uml(conn, suite, profile, target):
traits = get_traits(conn, profile)
tp = TraitParent(conn, suite)
pp = TraitPackage(conn, suite)
packages = " ".join([p.package for p in pp.all_packages(traits, tp)])
os.system("chroot %s apt-get update" % target)
os.system("chroot %s apt-get -y install %s" % (target, packages))
def __init__(self, conn, suite, trait):
self.menu = make_menu(TEMPL_CMDS, self.template_command)
self.conn = conn
self.current_trait = trait
self.traittemplate = TraitTemplate(self.conn, suite)
self.traittemplate.set_trait(self.current_trait)
self.traitpackage = TraitPackage(self.conn, suite)
self.traitpackage.set_trait(self.current_trait)
self.current_template = None
self.cfg = PaellaConfig()
self.template_path = '/nowhere'
self._tmp_path = '/nowhere'
self.tarball_path = self.cfg.get('management_gui', 'bkuptarball_path')
ListNoteBook.__init__(self)
self.set_suite(suite)
self.extracted = None
self.reset_rows()
self.dialogs = {}.fromkeys(['attach', 'rootsel'])
def __init__(self, conn, suite, trait):
self.menu = make_menu(TEMPL_CMDS, self.template_command)
self.conn = conn
self.current_trait = trait
self.traittemplate = TraitTemplate(self.conn, suite)
self.traittemplate.set_trait(self.current_trait)
self.traitpackage = TraitPackage(self.conn, suite)
self.traitpackage.set_trait(self.current_trait)
self.current_template = None
self.cfg = PaellaConfig()
self.template_path = '/nowhere'
self._tmp_path = '/nowhere'
self.tarball_path = self.cfg.get('management_gui', 'bkuptarball_path')
ListNoteBook.__init__(self)
self.set_suite(suite)
self.extracted = None
self.reset_rows()
self.dialogs = {}.fromkeys(['attach', 'rootsel'])
def get_profile_packages(conn, suite, profile):
traits = get_traits(conn, profile)
tp = TraitParent(conn, suite)
pp = TraitPackage(conn, suite)
packages = [p.package for p in pp.all_packages(traits, tp)]
return packages
def __set_suitecursors__(self):
self.traitparent = TraitParent(self.conn, self.suite)
self.traittemplate = TraitTemplate(self.conn, self.suite)
self.traitpackage = TraitPackage(self.conn, self.suite)
class TemplateEnvironment(ScrolledWindow):
def __init__(self, conn):
ScrolledWindow.__init__(self)
self.conn = conn
self.editor = TemplateEditor()
self.menu = SimpleMenu()
self.editor.connect('populate-popup', self.populate_menu, self.menu)
self.add_with_viewport(self.editor)
self.show()
def set_suite(self, suite):
self.suite = suite
self.__set_suitecursors__()
def __set_suitecursors__(self):
self.traitparent = TraitParent(self.conn, self.suite)
self.traittemplate = TraitTemplate(self.conn, self.suite)
self.traitpackage = TraitPackage(self.conn, self.suite)
def set_trait(self, trait):
self.trait = trait
self.traitparent.set_trait(trait)
self.traittemplate.set_trait(trait)
self.traitpackage.set_trait(trait)
self.__set_environment__()
def __set_environment__(self):
self.environ = dict(self.traitparent.get_environment([self.trait]))
self.sections = dict([(k, v.keys()) for k, v in self.environ.items()])
def populate_menu(self, widget, mainmenu, tmenu):
self.__set_environment__()
populate_menu(mainmenu, '_define_', ['_create_'], self.make_new_tag)
for section, vars in self.sections.items():
populate_menu(mainmenu, section, vars, self.make_tag)
def make_tag(self, menuitem, name, parent):
parentname = parent.get_name()
tagname = ujoin(parentname, name)
self.editor.make_tag(tagname)
def make_new_tag(self, menuitem, name, parent):
parentname = parent.get_name()
if (parentname, name) == ('_define_', '_create_'):
self.editor.create_new_tag(self.create_entry)
def create_entry(self, *args):
var = dict(self.editor.dialogs['create'].items())
debug('var is %s' % var)
self.environ[self.trait][var['name']] = var['value']
tagname = ujoin(self.trait, var['name'])
self.editor.make_tag(tagname)
self.editor.destroy_dialog(self.editor.dialogs['create'])
def preview(self, *args):
subs = self.traitparent.get_superdict(self.environ.keys())
self.editor.buffer.set_subs(subs)
self.editor.preview(*args)
def set_text(self, text):
self.editor.buffer.set_text(text)
def get_text(self):
return self.editor.get_text()
class TemplateBrowser(ListNoteBook):
def __init__(self, conn, suite, trait):
self.menu = make_menu(TEMPL_CMDS, self.template_command)
self.conn = conn
self.current_trait = trait
self.traittemplate = TraitTemplate(self.conn, suite)
self.traittemplate.set_trait(self.current_trait)
self.traitpackage = TraitPackage(self.conn, suite)
self.traitpackage.set_trait(self.current_trait)
self.current_template = None
self.cfg = PaellaConfig()
self.template_path = '/nowhere'
self._tmp_path = '/nowhere'
self.tarball_path = self.cfg.get('management_gui', 'bkuptarball_path')
ListNoteBook.__init__(self)
self.set_suite(suite)
self.extracted = None
self.reset_rows()
self.dialogs = {}.fromkeys(['attach', 'rootsel'])
def reset_rows(self):
rows = self.traittemplate.templates(fields=['template', 'package'])
self.set_rows(rows)
self.set_row_select(self.template_selected)
self.templates = [r.template for r in rows]
def template_selected(self, listbox, row, column, event):
row = listbox.get_selected_data()[0]
self.set_template(row.package, row.template)
def set_template(self, package, template):
self.current_package = package
self.current_template = template
if template not in self.pages:
trait = self.current_trait
nbook = TemplateNotebook(self.conn, self.cfg, self.suite, trait,
package, template, self.extracted)
self.append_page(nbook, template)
else:
self.set_current_page(template)
def template_filename(self, package, template):
tpath = join(self.template_path, self.suite, self.current_trait)
return join(tpath, package, template + '.template')
def suite_template_path(self, filesel=False):
path = join(self.template_path, self.suite)
if filesel:
path += '/'
return path
def trait_temp_path(self, filesel=False):
path = join(self._tmp_path, self.suite, self.current_trait)
if filesel:
path += '/'
return path
def set_suite(self, suite):
self.suite = suite
def save_template(self):
try:
template = self.get_selected_data()[0].template
self.pages[template].save_template()
except IndexError:
dialogs.Message('a template must be selected')
def edit_template(self):
try:
template = self.get_selected_data()[0].template
self.pages[template].edit_template()
except IndexError:
dialogs.Message('a template must be selected')
def template_command(self, meuitem, command):
if command in ['new']:
path = self.trait_temp_path(filesel=True)
select_a_file('new', path, self.fileselect_ok)
elif command == 'diff':
path = self.suite_template_path(filesel=True)
select_a_file('load', path, self.fileselect_ok)
elif command == 'save':
self.save_template()
elif command == 'load':
path = self.suite_template_path(filesel=True)
select_a_file('load', path, self.fileselect_ok)
elif command == 'done':
try:
template = self.get_selected_data()[0].template
self.remove_page(template)
except IndexError:
pass
elif command == 'drop':
print 'need to drop template'
rows = self.get_selected_data()
if len(rows):
row = rows[0]
self.traittemplate.drop_template(row.package, row.template)
self.remove_page(row.template)
self.reset_rows()
else:
dialogs.Message('a template must be selected')
elif command == 'root':
if self.dialogs['rootsel'] is None:
path = self.tarball_path + '/'
select_a_file('root', path, self.tarball_selected)
elif command == 'edit':
self.edit_template()
def tarball_selected(self, button, fileselect):
path = fileselect.get_filename()
fileselect.destroy()
self.dialogs['rootsel'] = select_from_tarfile('heydude', path,
self.pull_from_tar)
def pull_from_tar(self, button, fileselect):
info, tfile = fileselect.extract_file()
template = tfile.name
action = 'attach'
if self.dialogs[action] is None:
msg = 'attach to which package?'
self.dialogs[action] = dialogs.CList(msg, name=action)
lbox = self.dialogs[action]
lbox.set_rows(self.traitpackage.packages())
lbox.set_ok(self.insert_new_template_from_tar)
lbox.set_cancel(self.destroy_dialog)
lbox.set_data('tarmember', (info, tfile))
def insert_new_template_from_tar(self, button):
lbox = self.dialogs['attach']
rows = lbox.get_selected_data()
if len(rows) == 1:
package = rows[0].package
info, tfile = lbox.get_data('tarmember')
self.destroy_dialog(lbox)
self._insert_new_template(package, info.name, tfile, info)
def _insert_new_template(self, package, template, fileobj, info):
fileobj.seek(0)
filename = self.template_filename(package, template)
data = dict(owner=info.uname,
grp_owner=info.gname,
mode=oct(info.mode),
package=package,
template=template)
self.traittemplate.insert_template(data, fileobj)
self.set_template(package, template)
self.reset_rows()
def insert_new_template(self, package, template, path):
newfile = readfile(path)
filename = self.template_filename(package, template)
makepaths(dirname(filename))
writefile(filename, newfile)
try:
self.traittemplate.insert_template(
dict(package=package, template=template), file(path))
except OperationalError:
dialogs.Message('template already exists')
self.set_template(package, template)
self.reset_rows()
def load_template(self, path):
template, package = get_file_path(path, self.suite_template_path())
if template[-9:] == '.template':
template = template[:-9]
if template not in self.templates:
try:
orig = self.find_original(template)
self.insert_new_template(package, template, path)
except NoExistError:
dialogs.Message('%s not in extracted packages' % template)
def _diff(self, template, path):
current_template = self.template_filename(template)
os.popen2('meld %s %s' % (current_template, path))
def fileselect_ok(self, button, filesel):
path = filesel.get_filename()
action = filesel.get_data('action')
filesel.destroy()
if action == 'new':
template, package = get_file_path(path, self.trait_temp_path())
if template not in self.templates:
self.insert_new_template(package, template, path)
else:
dialogs.Message('template already exists')
elif action == 'diff':
pass
elif action == 'load':
self.load_template(path)
def set_extracted(self, extracted):
self.extracted = extracted
for page in self.pages.values():
page.extracted = extracted
def _extract_packages(self):
dialogs.Message('deprecated(for now)')
if False:
if self.extracted is None:
packages = [p.package for p in self.traitpackage.packages()]
path = self.trait_temp_path()
self.set_extracted(True)
packs = ',\n'.join(packages)
message = 'extracted packages:\n %s into:\n%s' % (packs, path)
dialogs.Message(message)
else:
dialogs.Message('already extracted')
def extract_packages(self):
self._extract_packages()
def __set_suitecursors__(self):
self.traitparent = TraitParent(self.conn, self.suite)
self.traittemplate = TraitTemplate(self.conn, self.suite)
self.traitpackage = TraitPackage(self.conn, self.suite)
def get_profile_packages(conn, suite, profile):
traits = get_traits(conn, profile)
tp = TraitParent(conn, suite)
pp = TraitPackage(conn, suite)
packages = [p.package for p in pp.all_packages(traits, tp)]
return packages
class TemplateBrowser(ListNoteBook):
def __init__(self, conn, suite, trait):
self.menu = make_menu(TEMPL_CMDS, self.template_command)
self.conn = conn
self.current_trait = trait
self.traittemplate = TraitTemplate(self.conn, suite)
self.traittemplate.set_trait(self.current_trait)
self.traitpackage = TraitPackage(self.conn, suite)
self.traitpackage.set_trait(self.current_trait)
self.current_template = None
self.cfg = PaellaConfig()
self.template_path = '/nowhere'
self._tmp_path = '/nowhere'
self.tarball_path = self.cfg.get('management_gui', 'bkuptarball_path')
ListNoteBook.__init__(self)
self.set_suite(suite)
self.extracted = None
self.reset_rows()
self.dialogs = {}.fromkeys(['attach', 'rootsel'])
def reset_rows(self):
rows = self.traittemplate.templates(fields=['template', 'package'])
self.set_rows(rows)
self.set_row_select(self.template_selected)
self.templates = [r.template for r in rows]
def template_selected(self, listbox, row, column, event):
row = listbox.get_selected_data()[0]
self.set_template(row.package, row.template)
def set_template(self, package, template):
self.current_package = package
self.current_template = template
if template not in self.pages:
trait = self.current_trait
nbook = TemplateNotebook(self.conn, self.cfg, self.suite, trait,
package, template, self.extracted)
self.append_page(nbook, template)
else:
self.set_current_page(template)
def template_filename(self, package, template):
tpath = join(self.template_path, self.suite, self.current_trait)
return join(tpath, package, template + '.template')
def suite_template_path(self, filesel=False):
path = join(self.template_path, self.suite)
if filesel:
path += '/'
return path
def trait_temp_path(self, filesel=False):
path = join(self._tmp_path, self.suite, self.current_trait)
if filesel:
path += '/'
return path
def set_suite(self, suite):
self.suite = suite
def save_template(self):
try:
template = self.get_selected_data()[0].template
self.pages[template].save_template()
except IndexError:
dialogs.Message('a template must be selected')
def edit_template(self):
try:
template = self.get_selected_data()[0].template
self.pages[template].edit_template()
except IndexError:
dialogs.Message('a template must be selected')
def template_command(self, meuitem, command):
if command in ['new']:
path = self.trait_temp_path(filesel=True)
select_a_file('new', path, self.fileselect_ok)
elif command == 'diff':
path = self.suite_template_path(filesel=True)
select_a_file('load', path, self.fileselect_ok)
elif command == 'save':
self.save_template()
elif command == 'load':
path = self.suite_template_path(filesel=True)
select_a_file('load', path, self.fileselect_ok)
elif command == 'done':
try:
template = self.get_selected_data()[0].template
self.remove_page(template)
except IndexError:
pass
elif command == 'drop':
print 'need to drop template'
rows = self.get_selected_data()
if len(rows):
row = rows[0]
self.traittemplate.drop_template(row.package, row.template)
self.remove_page(row.template)
self.reset_rows()
else:
dialogs.Message('a template must be selected')
elif command == 'root':
if self.dialogs['rootsel'] is None:
path = self.tarball_path + '/'
select_a_file('root', path, self.tarball_selected)
elif command == 'edit':
self.edit_template()
def tarball_selected(self, button, fileselect):
path = fileselect.get_filename()
fileselect.destroy()
self.dialogs['rootsel'] = select_from_tarfile('heydude', path, self.pull_from_tar)
def pull_from_tar(self, button, fileselect):
info, tfile = fileselect.extract_file()
template = tfile.name
action = 'attach'
if self.dialogs[action] is None:
msg = 'attach to which package?'
self.dialogs[action] = dialogs.CList(msg, name=action)
lbox = self.dialogs[action]
lbox.set_rows(self.traitpackage.packages())
lbox.set_ok(self.insert_new_template_from_tar)
lbox.set_cancel(self.destroy_dialog)
lbox.set_data('tarmember', (info, tfile))
def insert_new_template_from_tar(self, button):
lbox = self.dialogs['attach']
rows = lbox.get_selected_data()
if len(rows) == 1:
package = rows[0].package
info, tfile = lbox.get_data('tarmember')
self.destroy_dialog(lbox)
self._insert_new_template(package, info.name, tfile, info)
def _insert_new_template(self, package, template, fileobj, info):
fileobj.seek(0)
filename = self.template_filename(package, template)
data = dict(owner=info.uname, grp_owner=info.gname,
mode=oct(info.mode), package=package,
template=template)
self.traittemplate.insert_template(data, fileobj)
self.set_template(package, template)
self.reset_rows()
def insert_new_template(self, package, template, path):
newfile = readfile(path)
filename = self.template_filename(package, template)
makepaths(dirname(filename))
writefile(filename, newfile)
try:
self.traittemplate.insert_template(dict(package=package, template=template),
file(path))
except OperationalError:
dialogs.Message('template already exists')
self.set_template(package, template)
self.reset_rows()
def load_template(self, path):
template, package = get_file_path(path, self.suite_template_path())
if template[-9:] == '.template':
template = template[:-9]
if template not in self.templates:
try:
orig = self.find_original(template)
self.insert_new_template(package, template, path)
except NoExistError:
dialogs.Message('%s not in extracted packages' %template)
def _diff(self, template, path):
current_template = self.template_filename(template)
os.popen2('meld %s %s' %(current_template, path))
def fileselect_ok(self, button, filesel):
path = filesel.get_filename()
action = filesel.get_data('action')
filesel.destroy()
if action == 'new':
template, package = get_file_path(path, self.trait_temp_path())
if template not in self.templates:
self.insert_new_template(package, template, path)
else:
dialogs.Message('template already exists')
elif action == 'diff':
pass
elif action == 'load':
self.load_template(path)
def set_extracted(self, extracted):
self.extracted = extracted
for page in self.pages.values():
page.extracted = extracted
def _extract_packages(self):
dialogs.Message('deprecated(for now)')
if False:
if self.extracted is None:
packages = [p.package for p in self.traitpackage.packages()]
path = self.trait_temp_path()
self.set_extracted(True)
packs = ',\n'.join(packages)
message = 'extracted packages:\n %s into:\n%s'%(packs, path)
dialogs.Message(message)
else:
dialogs.Message('already extracted')
def extract_packages(self):
self._extract_packages()
def __init__(self, conn, suite, cfg):
Installer.__init__(self, conn, cfg=cfg)
self.traitpackage = TraitPackage(conn, suite)
self.traittemplate = TraitTemplate(conn, suite)
self.traitdebconf = TraitDebconf(conn, suite)
self.traitscripts = TraitScript(conn, suite)
class TraitInstaller(Installer):
def __init__(self, conn, suite, cfg):
Installer.__init__(self, conn, cfg=cfg)
self.traitpackage = TraitPackage(conn, suite)
self.traittemplate = TraitTemplate(conn, suite)
self.traitdebconf = TraitDebconf(conn, suite)
self.traitscripts = TraitScript(conn, suite)
def set_trait(self, trait):
self.traitpackage.set_trait(trait)
self.traittemplate.set_trait(trait)
self.traitdebconf.set_trait(trait)
self.traitscripts.set_trait(trait)
self._current_trait_ = trait
self.log.info('trait set to %s' % self._current_trait_)
def run(self, name, command, args='', proc=False, chroot=True,
keeprunning=False):
tname = 'trait-%s-%s' % (self._current_trait_, name)
Installer.run(self, tname, command, args=args, proc=proc,
chroot=chroot,
keeprunning=keeprunning)
def runscript(self, script, name, info, chroot=False):
self.log.info(info['start'])
self.run(name, script, chroot=chroot)
os.remove(script)
self.log.info(info['done'])
def process(self):
self.log.info('processing %s' % self._current_trait_)
os.environ['PAELLA_TARGET'] = self.target
os.environ['PAELLA_TRAIT'] = self._current_trait_
packages = self.traitpackage.packages()
templates = self.traittemplate.templates()
#start pre script
script = self._make_script('pre')
if script is not None:
info = dict(start='pre script started',
done='pre script done')
self.runscript(script, 'pre-script', info)
#remove packages
script = self._make_script('remove')
if script is None:
remove = [p for p in packages if p.action == 'remove']
if len(remove):
self.remove(remove)
else:
info = dict(start='remove script started',
done='remove script done')
self.runscript(script, 'remove-script', info)
#install packages
script = self._make_script('install')
if script is None:
install = [p for p in packages if p.action == 'install']
if len(install):
self.install(install, templates)
else:
info = dict(start='install script started',
done='install script done')
self.runscript(script, 'install-script', info)
#configure packages
script = self._make_script('config')
if script is None:
config = [p for p in packages if p.action in ['install', 'config']]
if len(config):
self.configure(config, templates)
else:
info = dict(start='config script started',
done='config script done')
self.runscript(script, 'config-script', info)
#reconfigure debconf
script = self._make_script('reconfig')
if script is None:
self.reconfigure_debconf()
else:
info = dict(start='reconfig script started',
done='reconfig script done')
self.runscript(script, 'reconfig-script', info)
#start post script
script = self._make_script('post')
if script is not None:
info = dict(start='post script started',
done='post script done')
self.runscript(script, 'post-script', info)
def remove(self, packages):
packages = ' '.join([p.package for p in packages])
command, args = 'apt-get -y remove', packages
self.run('remove', command, args=args, proc=True)
def install(self, packages, templates):
package_args = ' '.join([p.package for p in packages])
cmd = 'apt-get -y --force-yes install %s\n' % package_args
cmd += 'rm /var/cache/apt/archives/*.deb -f'
#os.system(self.with_proc(cmd))
run = self.run('install', cmd, proc=True, keeprunning=True)
if run:
self.log.warn('PROBLEM installing %s' % self._current_trait_)
self.log.warn('packages --> %s' % package_args)
def configure(self, packages, templates):
dpkg_rec = False
for p in packages:
for t in [t for t in templates if t.package == p.package]:
if t.template == 'var/cache/debconf/config.dat':
dpkg_rec = True
self.log.info('Installing Debconf template ...')
self.install_debconf_template(t)
else:
self.make_template(t)
if dpkg_rec:
self.log.info('Reconfiguring packages')
for p in packages:
cmd = 'dpkg-reconfigure -plow %s' % p.package
run = self.run('dpkg-recfg', cmd, proc=True, keeprunning=True)
if run:
self.log.info('reconfigure failed on %s' % p.package)
else:
self.log.info('%s reconfigured' % p.package)
script = self._make_script('chroot', execpath=True)
if script is not None:
#os.system(self.command(script))
self.run('chroot-script', script)
if script[0] == '/':
script = script[1:]
os.remove(join(self.target, script))
def _make_script(self, name, execpath=False):
script = self.traitscripts.get(name)
if script is not None:
exec_path = join('/tmp', name + '-script')
target_path = join(self.target, 'tmp', name + '-script')
sfile = file(target_path, 'w')
sfile.write(script.read())
sfile.close()
os.system('chmod 755 %s' % target_path)
if not execpath:
return target_path
else:
return exec_path
else:
return None
def make_template(self, template):
self.traittemplate.set_template(template.package, template.template)
tmpl = self.traittemplate.template.template
self.traittemplate.template.update(self.familydata)
self.traittemplate.template.update(self.profiledata)
self._make_template_common(template, tmpl)
def make_template_with_data(self, template, data):
self.traittemplate.set_template(template.package, template.template)
tmpl = self.traittemplate.template.template
self.traittemplate.template.update(data)
self._make_template_common(template, tmpl)
def _make_template_common(self, template, tmpl):
sub = self.traittemplate.template.sub()
newpath = join(self.target, template.template)
self.log.info('target template %s' % newpath)
dir = dirname(newpath)
if not isdir(dir):
makepaths(dir)
if tmpl != sub:
self.log.info('%s %s subbed' % (template.package, template.template))
newfile = file(newpath, 'w')
newfile.write(sub)
newfile.close()
mode = template.mode
if mode[0] == '0' and len(mode) <= 7 and mode.isdigit():
mode = eval(mode)
os.chmod(newpath, mode)
own = ':'.join([template.owner, template.grp_owner])
os.system(self.command('chown', '%s %s' %(own, join('/', template.template))))
def install_debconf_template(self, template):
self.log.info('Installing debconf for %s' % self._current_trait_)
self.traittemplate.set_template(template.package, template.template)
tmpl = self.traittemplate.template.template
self.traittemplate.template.update(self.profiledata)
sub = self.traittemplate.template.sub()
if tmpl == sub:
self.log.info('static debconf, no substitutions')
self.log.info('for trait %s ' % self._current_trait_)
config_path = join(self.target, 'tmp/paella_debconf')
if isfile(config_path):
raise Error, '%s is not supposed to be there' % config_path
debconf = file(config_path, 'w')
debconf.write(sub + '\n')
debconf.close()
target_path = join(self.target, 'var/cache/debconf/config.dat')
self.log.info('debconf config is %s %s' % (config_path, target_path))
copy_configdb(config_path, target_path)
os.remove(config_path)
def set_template_path(self, path):
self.traittemplate.template.set_path(path)
def install_debconf(self):
config = self.traitdebconf.get_config()
config_path = join(self.target, 'tmp/paella_debconf')
if isfile(config_path):
raise Error, '%s is not supposed to be there' % config_path
debconf = file(config_path, 'w')
debconf.write(config + '\n')
debconf.close()
target_path = join(self.target, 'var/cache/debconf/config.dat')
self.log.info('debconf config is %s %s' % (config_path, target_path))
cmd = install_debconf(config_path, target_path)
command = 'sh -c "%s"' % cmd
self.log.info(cmd)
os.system(cmd)
os.remove(config_path)
def reconfigure_debconf(self):
owners = self.traitdebconf.all_owners()
self.log.info('ALL OWNERS %s' % owners)
os.environ['DEBIAN_FRONTEND'] = 'noninteractive'
for owner in owners:
self.log.info('RECONFIGURING %s' % owner)
os.system(self.command('dpkg-reconfigure -plow %s' % owner))
def __init__(self, conn, suite, cfg):
Installer.__init__(self, conn, cfg=cfg)
self.traitpackage = TraitPackage(conn, suite)
self.traittemplate = TraitTemplate(conn, suite)
self.traitdebconf = TraitDebconf(conn, suite)
self.traitscripts = TraitScript(conn, suite)
class TraitInstaller(Installer):
def __init__(self, conn, suite, cfg):
Installer.__init__(self, conn, cfg=cfg)
self.traitpackage = TraitPackage(conn, suite)
self.traittemplate = TraitTemplate(conn, suite)
self.traitdebconf = TraitDebconf(conn, suite)
self.traitscripts = TraitScript(conn, suite)
def set_trait(self, trait):
self.traitpackage.set_trait(trait)
self.traittemplate.set_trait(trait)
self.traitdebconf.set_trait(trait)
self.traitscripts.set_trait(trait)
self._current_trait_ = trait
self.log.info('trait set to %s' % self._current_trait_)
def run(self, name, command, args='', proc=False, chroot=True,
keeprunning=False):
tname = 'trait-%s-%s' % (self._current_trait_, name)
Installer.run(self, tname, command, args=args, proc=proc,
chroot=chroot,
keeprunning=keeprunning)
def runscript(self, script, name, info, chroot=False):
self.log.info(info['start'])
self.run(name, script, chroot=chroot)
os.remove(script)
self.log.info(info['done'])
def process(self):
self.log.info('processing %s' % self._current_trait_)
os.environ['PAELLA_TARGET'] = self.target
os.environ['PAELLA_TRAIT'] = self._current_trait_
packages = self.traitpackage.packages()
templates = self.traittemplate.templates()
#start pre script
script = self._make_script('pre')
if script is not None:
info = dict(start='pre script started',
done='pre script done')
self.runscript(script, 'pre-script', info)
#remove packages
script = self._make_script('remove')
if script is None:
remove = [p for p in packages if p.action == 'remove']
if len(remove):
self.remove(remove)
else:
info = dict(start='remove script started',
done='remove script done')
self.runscript(script, 'remove-script', info)
#install packages
script = self._make_script('install')
if script is None:
install = [p for p in packages if p.action == 'install']
if len(install):
self.install(install, templates)
else:
info = dict(start='install script started',
done='install script done')
self.runscript(script, 'install-script', info)
#configure packages
script = self._make_script('config')
if script is None:
config = [p for p in packages if p.action in ['install', 'config']]
if len(config):
self.configure(config, templates)
else:
info = dict(start='config script started',
done='config script done')
self.runscript(script, 'config-script', info)
#reconfigure debconf
script = self._make_script('reconfig')
if script is None:
self.reconfigure_debconf()
else:
info = dict(start='reconfig script started',
done='reconfig script done')
self.runscript(script, 'reconfig-script', info)
#start post script
script = self._make_script('post')
if script is not None:
info = dict(start='post script started',
done='post script done')
self.runscript(script, 'post-script', info)
def remove(self, packages):
packages = ' '.join([p.package for p in packages])
command, args = 'apt-get -y remove', packages
self.run('remove', command, args=args, proc=True)
def install(self, packages, templates):
package_args = ' '.join([p.package for p in packages])
cmd = 'apt-get -y --force-yes install %s\n' % package_args
cmd += 'rm /var/cache/apt/archives/*.deb -f'
#os.system(self.with_proc(cmd))
run = self.run('install', cmd, proc=True, keeprunning=True)
if run:
self.log.warn('PROBLEM installing %s' % self._current_trait_)
self.log.warn('packages --> %s' % package_args)
def configure(self, packages, templates):
dpkg_rec = False
for p in packages:
for t in [t for t in templates if t.package == p.package]:
if t.template == 'var/cache/debconf/config.dat':
dpkg_rec = True
self.log.info('Installing Debconf template ...')
self.install_debconf_template(t)
else:
self.make_template(t)
if dpkg_rec:
self.log.info('Reconfiguring packages')
for p in packages:
cmd = 'dpkg-reconfigure -plow %s' % p.package
run = self.run('dpkg-recfg', cmd, proc=True, keeprunning=True)
if run:
self.log.info('reconfigure failed on %s' % p.package)
else:
self.log.info('%s reconfigured' % p.package)
script = self._make_script('chroot', execpath=True)
if script is not None:
#os.system(self.command(script))
self.run('chroot-script', script)
if script[0] == '/':
script = script[1:]
os.remove(join(self.target, script))
def _make_script(self, name, execpath=False):
script = self.traitscripts.get(name)
if script is not None:
exec_path = join('/tmp', name + '-script')
target_path = join(self.target, 'tmp', name + '-script')
sfile = file(target_path, 'w')
sfile.write(script.read())
sfile.close()
os.system('chmod 755 %s' % target_path)
if not execpath:
return target_path
else:
return exec_path
else:
return None
def make_template(self, template):
self.traittemplate.set_template(template.package, template.template)
tmpl = self.traittemplate.template.template
self.traittemplate.template.update(self.familydata)
self.traittemplate.template.update(self.profiledata)
self._make_template_common(template, tmpl)
def make_template_with_data(self, template, data):
self.traittemplate.set_template(template.package, template.template)
tmpl = self.traittemplate.template.template
self.traittemplate.template.update(data)
self._make_template_common(template, tmpl)
def _make_template_common(self, template, tmpl):
sub = self.traittemplate.template.sub()
newpath = join(self.target, template.template)
self.log.info('target template %s' % newpath)
dir = dirname(newpath)
if not isdir(dir):
makepaths(dir)
if tmpl != sub:
self.log.info('%s %s subbed' % (template.package, template.template))
newfile = file(newpath, 'w')
newfile.write(sub)
newfile.close()
mode = template.mode
if mode[0] == '0' and len(mode) <= 7 and mode.isdigit():
mode = eval(mode)
os.chmod(newpath, mode)
own = ':'.join([template.owner, template.grp_owner])
os.system(self.command('chown', '%s %s' %(own, join('/', template.template))))
def install_debconf_template(self, template):
self.log.info('Installing debconf for %s' % self._current_trait_)
self.traittemplate.set_template(template.package, template.template)
tmpl = self.traittemplate.template.template
self.traittemplate.template.update(self.profiledata)
sub = self.traittemplate.template.sub()
if tmpl == sub:
self.log.info('static debconf, no substitutions')
self.log.info('for trait %s ' % self._current_trait_)
config_path = join(self.target, 'tmp/paella_debconf')
if isfile(config_path):
raise Error, '%s is not supposed to be there' % config_path
debconf = file(config_path, 'w')
debconf.write(sub + '\n')
debconf.close()
target_path = join(self.target, 'var/cache/debconf/config.dat')
self.log.info('debconf config is %s %s' % (config_path, target_path))
copy_configdb(config_path, target_path)
os.remove(config_path)
def set_template_path(self, path):
self.traittemplate.template.set_path(path)
def install_debconf(self):
config = self.traitdebconf.get_config()
config_path = join(self.target, 'tmp/paella_debconf')
if isfile(config_path):
raise Error, '%s is not supposed to be there' % config_path
debconf = file(config_path, 'w')
debconf.write(config + '\n')
debconf.close()
target_path = join(self.target, 'var/cache/debconf/config.dat')
self.log.info('debconf config is %s %s' % (config_path, target_path))
cmd = install_debconf(config_path, target_path)
command = 'sh -c "%s"' % cmd
self.log.info(cmd)
os.system(cmd)
os.remove(config_path)
def reconfigure_debconf(self):
owners = self.traitdebconf.all_owners()
self.log.info('ALL OWNERS %s' % owners)
os.environ['DEBIAN_FRONTEND'] = 'noninteractive'
for owner in owners:
self.log.info('RECONFIGURING %s' % owner)
os.system(self.command('dpkg-reconfigure -plow %s' % owner))
class TemplateEnvironment(ScrolledWindow):
def __init__(self, conn):
ScrolledWindow.__init__(self)
self.conn = conn
self.editor = TemplateEditor()
self.menu = SimpleMenu()
self.editor.connect('populate-popup', self.populate_menu, self.menu)
self.add_with_viewport(self.editor)
self.show()
def set_suite(self, suite):
self.suite = suite
self.__set_suitecursors__()
def __set_suitecursors__(self):
self.traitparent = TraitParent(self.conn, self.suite)
self.traittemplate = TraitTemplate(self.conn, self.suite)
self.traitpackage = TraitPackage(self.conn, self.suite)
def set_trait(self, trait):
self.trait = trait
self.traitparent.set_trait(trait)
self.traittemplate.set_trait(trait)
self.traitpackage.set_trait(trait)
self.__set_environment__()
def __set_environment__(self):
self.environ = dict(self.traitparent.get_environment([self.trait]))
self.sections = dict([(k, v.keys()) for k,v in self.environ.items()])
def populate_menu(self, widget, mainmenu, tmenu):
self.__set_environment__()
populate_menu(mainmenu, '_define_', ['_create_'], self.make_new_tag)
for section, vars in self.sections.items():
populate_menu(mainmenu, section, vars, self.make_tag)
def make_tag(self, menuitem, name, parent):
parentname = parent.get_name()
tagname = ujoin(parentname, name)
self.editor.make_tag(tagname)
def make_new_tag(self, menuitem, name, parent):
parentname = parent.get_name()
if (parentname, name) == ('_define_', '_create_'):
self.editor.create_new_tag(self.create_entry)
def create_entry(self, *args):
var = dict(self.editor.dialogs['create'].items())
debug('var is %s' % var)
self.environ[self.trait][var['name']] = var['value']
tagname = ujoin(self.trait, var['name'])
self.editor.make_tag(tagname)
self.editor.destroy_dialog(self.editor.dialogs['create'])
def preview(self, *args):
subs = self.traitparent.get_superdict(self.environ.keys())
self.editor.buffer.set_subs(subs)
self.editor.preview(*args)
def set_text(self, text):
self.editor.buffer.set_text(text)
def get_text(self):
return self.editor.get_text()
def __rebuild_modules__(self):
del self[:]
for line in self.lines:
if line and line[0] != '#':
list.append(self, line)
def append(self, module):
if module not in self:
self.lines.append(module)
self.__rebuild_modules__()
def write(self, path=None):
if path is None:
path = self.path
mfile = file(path, 'w')
mfile.write('\n'.join(self.lines) + '\n')
mfile.close()
if __name__ == '__main__':
from useless.db.midlevel import StatementCursor
from useless.db.midlevel import Environment, TableDict
c = PaellaConnection()
tp = TraitParent(c, 'woody')
pp = TraitPackage(c, 'woody')
ct = ConfigTemplate()
path = '/tmp/spam.db'
db = bsddb.btopen('path', 'c')
p = Parser('var-table.csv')
class TraitInstaller(Installer):
def __init__(self, conn, suite, cfg):
Installer.__init__(self, conn, cfg=cfg)
self.traitpackage = TraitPackage(conn, suite)
self.traittemplate = TraitTemplate(conn, suite)
self.traitdebconf = TraitDebconf(conn, suite)
self.traitscripts = TraitScript(conn, suite)
def set_trait(self, trait):
self.traitpackage.set_trait(trait)
self.traittemplate.set_trait(trait)
self.traitdebconf.set_trait(trait)
self.traitscripts.set_trait(trait)
self._current_trait_ = trait
self.log.info("trait set to %s" % self._current_trait_)
def run(self, name, command, args="", proc=False, chroot=True, keeprunning=False):
tname = "trait-%s-%s" % (self._current_trait_, name)
Installer.run(self, tname, command, args=args, proc=proc, chroot=chroot, keeprunning=keeprunning)
def runscript(self, script, name, info, chroot=False):
self.log.info(info["start"])
self.run(name, script, chroot=chroot)
os.remove(script)
self.log.info(info["done"])
def process(self):
self.log.info("processing %s" % self._current_trait_)
os.environ["PAELLA_TARGET"] = self.target
os.environ["PAELLA_TRAIT"] = self._current_trait_
packages = self.traitpackage.packages()
templates = self.traittemplate.templates()
# start pre script
script = self._make_script("pre")
if script is not None:
info = dict(start="pre script started", done="pre script done")
self.runscript(script, "pre-script", info)
# remove packages
script = self._make_script("remove")
if script is None:
remove = [p for p in packages if p.action == "remove"]
if len(remove):
self.remove(remove)
else:
info = dict(start="remove script started", done="remove script done")
self.runscript(script, "remove-script", info)
# install packages
script = self._make_script("install")
if script is None:
install = [p for p in packages if p.action == "install"]
if len(install):
self.install(install, templates)
else:
info = dict(start="install script started", done="install script done")
self.runscript(script, "install-script", info)
# configure packages
script = self._make_script("config")
if script is None:
config = [p for p in packages if p.action in ["install", "config"]]
if len(config):
self.configure(config, templates)
else:
info = dict(start="config script started", done="config script done")
self.runscript(script, "config-script", info)
# reconfigure debconf
script = self._make_script("reconfig")
if script is None:
self.reconfigure_debconf()
else:
info = dict(start="reconfig script started", done="reconfig script done")
self.runscript(script, "reconfig-script", info)
# start post script
script = self._make_script("post")
if script is not None:
info = dict(start="post script started", done="post script done")
self.runscript(script, "post-script", info)
def remove(self, packages):
packages = " ".join([p.package for p in packages])
command, args = "apt-get -y remove", packages
self.run("remove", command, args=args, proc=True)
def install(self, packages, templates):
package_args = " ".join([p.package for p in packages])
cmd = "apt-get -y --force-yes install %s\n" % package_args
cmd += "rm /var/cache/apt/archives/*.deb -f"
# os.system(self.with_proc(cmd))
run = self.run("install", cmd, proc=True, keeprunning=True)
if run:
self.log.warn("PROBLEM installing %s" % self._current_trait_)
self.log.warn("packages --> %s" % package_args)
def configure(self, packages, templates):
dpkg_rec = False
for p in packages:
for t in [t for t in templates if t.package == p.package]:
if t.template == "var/cache/debconf/config.dat":
dpkg_rec = True
self.log.info("Installing Debconf template ...")
self.install_debconf_template(t)
else:
self.make_template(t)
if dpkg_rec:
self.log.info("Reconfiguring packages")
for p in packages:
cmd = "dpkg-reconfigure -plow %s" % p.package
run = self.run("dpkg-recfg", cmd, proc=True, keeprunning=True)
if run:
self.log.info("reconfigure failed on %s" % p.package)
else:
self.log.info("%s reconfigured" % p.package)
script = self._make_script("chroot", execpath=True)
if script is not None:
# os.system(self.command(script))
self.run("chroot-script", script)
if script[0] == "/":
script = script[1:]
os.remove(join(self.target, script))
def _make_script(self, name, execpath=False):
script = self.traitscripts.get(name)
if script is not None:
exec_path = join("/tmp", name + "-script")
target_path = join(self.target, "tmp", name + "-script")
sfile = file(target_path, "w")
sfile.write(script.read())
sfile.close()
os.system("chmod 755 %s" % target_path)
if not execpath:
return target_path
else:
return exec_path
else:
return None
def make_template(self, template):
self.traittemplate.set_template(template.package, template.template)
tmpl = self.traittemplate.template.template
self.traittemplate.template.update(self.familydata)
self.traittemplate.template.update(self.profiledata)
self._make_template_common(template, tmpl)
def make_template_with_data(self, template, data):
self.traittemplate.set_template(template.package, template.template)
tmpl = self.traittemplate.template.template
self.traittemplate.template.update(data)
self._make_template_common(template, tmpl)
def _make_template_common(self, template, tmpl):
sub = self.traittemplate.template.sub()
newpath = join(self.target, template.template)
self.log.info("target template %s" % newpath)
dir = dirname(newpath)
if not isdir(dir):
makepaths(dir)
if tmpl != sub:
self.log.info("%s %s subbed" % (template.package, template.template))
newfile = file(newpath, "w")
newfile.write(sub)
newfile.close()
mode = template.mode
if mode[0] == "0" and len(mode) <= 7 and mode.isdigit():
mode = eval(mode)
os.chmod(newpath, mode)
own = ":".join([template.owner, template.grp_owner])
os.system(self.command("chown", "%s %s" % (own, join("/", template.template))))
def install_debconf_template(self, template):
self.log.info("Installing debconf for %s" % self._current_trait_)
self.traittemplate.set_template(template.package, template.template)
tmpl = self.traittemplate.template.template
self.traittemplate.template.update(self.profiledata)
sub = self.traittemplate.template.sub()
if tmpl == sub:
self.log.info("static debconf, no substitutions")
self.log.info("for trait %s " % self._current_trait_)
config_path = join(self.target, "tmp/paella_debconf")
if isfile(config_path):
raise Error, "%s is not supposed to be there" % config_path
debconf = file(config_path, "w")
debconf.write(sub + "\n")
debconf.close()
target_path = join(self.target, "var/cache/debconf/config.dat")
self.log.info("debconf config is %s %s" % (config_path, target_path))
copy_configdb(config_path, target_path)
os.remove(config_path)
def set_template_path(self, path):
self.traittemplate.template.set_path(path)
def install_debconf(self):
config = self.traitdebconf.get_config()
config_path = join(self.target, "tmp/paella_debconf")
if isfile(config_path):
raise Error, "%s is not supposed to be there" % config_path
debconf = file(config_path, "w")
debconf.write(config + "\n")
debconf.close()
target_path = join(self.target, "var/cache/debconf/config.dat")
self.log.info("debconf config is %s %s" % (config_path, target_path))
cmd = install_debconf(config_path, target_path)
command = 'sh -c "%s"' % cmd
self.log.info(cmd)
os.system(cmd)
os.remove(config_path)
def reconfigure_debconf(self):
owners = self.traitdebconf.all_owners()
self.log.info("ALL OWNERS %s" % owners)
os.environ["DEBIAN_FRONTEND"] = "noninteractive"
for owner in owners:
self.log.info("RECONFIGURING %s" % owner)
os.system(self.command("dpkg-reconfigure -plow %s" % owner))
