class PaellaImporter(object):
def __init__(self, conn):
self.conn = conn
self.suitecursor = SuiteCursor(self.conn)
self.aptsrc = AptSourceHandler(self.conn)
self.main_path = None
self.profile = Profile(self.conn)
self.family = Family(self.conn)
self.diskconfig = DiskConfigHandler(self.conn)
self.aptkeys = AptKeyHandler(self.conn)
def set_main_path(self, dirname):
self.main_path = path(dirname)
def parse_main_xml(self, filename=None):
if filename is None:
filename = self.main_path / 'database.xml'
parsed = PaellaParser(filename)
return parsed
def start_schema(self):
try:
start_schema(self.conn)
except AlreadyPresentError:
print "primary tables already present"
def import_all_families(self, dirname=None):
if dirname is None:
dirname = self.main_path / 'families'
xmlfiles = dirname.listdir('*.xml')
self.report_total_families(len(xmlfiles))
while xmlfiles:
familyxml = xmlfiles.pop(0)
try:
self.import_family(familyxml)
except UnbornError:
xmlfiles.append(familyxml)
#print 'import families from', dirname
def import_family(self, filename):
self.family.import_family_xml(filename)
self.report_family_imported(filename.namebase)
def import_profile(self, filename):
self.profile.import_profile(filename)
def import_all_profiles(self, dirname=None):
if dirname is None:
dirname = self.main_path / 'profiles'
dirname = path(dirname)
xmlfiles = dirname.listdir('*.xml')
self.report_total_profiles(len(xmlfiles))
for xmlfile in xmlfiles:
self.profile.import_profile(xmlfile)
self.report_profile_imported(xmlfile.namebase)
# warning, this is quick and sloppy
def import_aptkey(self, filename):
filename = path(filename).abspath()
basename = filename.basename()
name = basename.split('.')[0]
data = file(filename).read()
self.aptkeys.insert_key(name, data)
def import_all_aptkeys(self, dirname=None):
if dirname is None:
dirname = self.main_path / 'aptkeys'
dirname = path(dirname)
files = [
f for f in dirname.listdir() if f.isfile() and f.endswith('.gpg')
]
for filename in files:
self.import_aptkey(filename)
# warning, this is quick and sloppy
def import_diskconfig(self, filename):
filename = path(filename).abspath()
basename = filename.basename()
name = basename.split('.')[0]
cursor = self.conn.cursor(statement=True)
content = file(filename).read()
data = dict(name=name, content=content)
cursor.insert(table='diskconfig', data=data)
def import_all_diskconfigs(self, dirname=None):
if dirname is None:
dirname = self.main_path / 'diskconfig'
dirname = path(dirname)
files = [afile for afile in dirname.listdir() if afile.isfile()]
cursor = self.conn.cursor(statement=True)
for diskconfig in files:
name = diskconfig.basename()
data = dict(name=name, content=file(diskconfig).read())
cursor.insert(table='diskconfig', data=data)
# here suite is a parsed xml object (find name)
def make_suite(self, suite):
current_suites = self.suitecursor.get_suites()
if suite.name not in current_suites:
apt_ids = [e.apt_id for e in suite.aptsources]
self.suitecursor.make_suite(suite.name, apt_ids)
os = suite['os']
if not os:
os = None
self.suitecursor.set_os(os, suite=suite.name)
else:
raise RuntimeError, 'suite %s already exists' % suite
# aptsources is the PaellaParser.aptsources attribute
def import_apt_sources(self, aptsources):
self.report_total_apt_sources(len(aptsources))
for apt in aptsources:
self.import_parsed_apt_source(apt)
# here apt is an AptSourceParser object
def import_parsed_apt_source(self, apt):
self.report_importing_aptsrc(apt.apt_id)
self.aptsrc.insert_apt_source_row(apt.apt_id, apt.uri, apt.dist,
apt.sections, apt.local_path)
if not os.environ.has_key('PAELLA_DB_NOPACKAGETABLES'):
self.aptsrc.insert_packages(apt.apt_id)
self.report_aptsrc_imported(apt.apt_id)
def _import_traits(self, suite, traitlist, dirname):
self.report_total_traits(len(traitlist))
if not os.environ.has_key('PAELLA_DB_NOPACKAGETABLES'):
missing = self._find_missing_packages(suite, traitlist, dirname)
else:
missing = False
if missing:
self.report_missing_packages(suite, missing)
raise MissingPackagesError, report_missing_packages(suite, missing)
else:
while len(traitlist):
trait = traitlist.pop(0)
try:
self._import_trait(suite, dirname / trait)
self.report_trait_imported(trait, len(traitlist))
except UnbornError:
traitlist.append(trait)
# the dirname here must have the trait.xml and
# scripts and templates for the trait
def _import_trait(self, suite, dirname):
traitdb = Trait(self.conn, suite)
traitdb.insert_trait(dirname, suite)
def import_trait(self, suite, dirname):
self._import_trait(suite, dirname)
def _find_missing_packages(self, suite, traits, dirname):
missing = dict()
traitdb = Trait(self.conn, suite)
for trait in traits:
tdir = dirname / trait
traitxml = traitdb.parse_trait_xml(tdir, suite=suite)
missing_list = traitdb.find_missing_packages(traitxml)
if missing_list:
missing[trait] = missing_list
return missing
def perform_full_import(self, dirname):
self.set_main_path(dirname)
dbdata = self.parse_main_xml()
self.start_schema()
self.import_apt_sources(dbdata.aptsources)
self.report_total_suites(len(dbdata.suites))
for suite in dbdata.suites:
self.make_suite(suite)
suitedir = self.main_path / suite.name
self._import_traits(suite.name, dbdata.get_traits(suite.name),
suitedir)
self.report_suite_imported(suite.name)
self.import_all_families()
self.import_all_profiles()
self.import_all_diskconfigs()
machinedb = self.main_path / 'machine_database.xml'
if machinedb.isfile():
mh = MachineHandler(self.conn)
mh.import_machine_database(self.main_path)
default_environment_basename = 'default-environment'
filename = self.main_path / default_environment_basename
if filename.isfile():
# similar code exists in kde/environ.py
defenv = DefaultEnvironment(self.conn)
newcfg = RawConfigParser()
newcfg.read(filename)
defenv.update(newcfg)
self.import_all_aptkeys()
###################
# reporting methods
####################
def report_missing_packages(self, suite, missing):
print report_missing_packages(suite, missing)
def report_total_apt_sources(self, total):
print 'importing %d apt sources' % total
def report_importing_aptsrc(self, apt_id):
print 'importing %s' % apt_id
def report_aptsrc_imported(self, apt_id):
print 'apt source %s imported' % apt_id
def report_total_suites(self, total):
print 'importing %d suites' % total
def report_importing_suite(self, suite):
print 'importing suite %s' % suite
def report_suite_imported(self, suite):
print 'suite %s imported' % suite
def report_total_traits(self, total):
print 'importing %d traits' % total
def report_importing_trait(self, trait, numtraits):
print 'importing trait', trait
def report_trait_imported(self, trait, numtraits):
print 'trait %s imported' % trait
def report_total_families(self, total):
print 'importing %d families' % total
def report_family_imported(self, family):
print 'family %s imported' % family
def report_total_profiles(self, total):
print 'importing %d profiles' % total
def report_profile_imported(self, profile):
print 'profile %s imported' % profile
class PaellaImporter(object):
def __init__(self, conn):
self.conn = conn
self.suitecursor = SuiteCursor(self.conn)
self.aptsrc = AptSourceHandler(self.conn)
self.main_path = None
self.profile = Profile(self.conn)
self.family = Family(self.conn)
def set_main_path(self, dirname):
self.main_path = path(dirname)
def parse_main_xml(self, filename=None):
if filename is None:
filename = self.main_path / 'database.xml'
parsed = PaellaParser(filename)
return parsed
def start_schema(self):
try:
start_schema(self.conn)
except AlreadyPresentError:
print "primary tables already present"
def import_all_families(self, dirname=None):
if dirname is None:
dirname = self.main_path / 'families'
xmlfiles = dirname.listdir('*.xml')
self.report_total_families(len(xmlfiles))
while xmlfiles:
familyxml = xmlfiles.pop(0)
try:
self.import_family(familyxml)
except UnbornError:
xmlfiles.append(familyxml)
print 'import families from', dirname
def import_family(self, filename):
self.family.import_family_xml(filename)
self.report_family_imported(filename.namebase)
def import_all_profiles(self, dirname=None):
if dirname is None:
dirname = self.main_path / 'profiles'
dirname = path(dirname)
xmlfiles = dirname.listdir('*.xml')
self.report_total_profiles(len(xmlfiles))
for xmlfile in xmlfiles:
self.profile.import_profile(xmlfile)
self.report_profile_imported(xmlfile.namebase)
def import_all_diskconfigs(self, dirname=None):
if dirname is None:
dirname = self.main_path / 'diskconfig'
dirname = path(dirname)
files = dirname.listdir()
cursor = self.conn.cursor(statement=True)
for diskconfig in files:
name= diskconfig.basename()
data = dict(name=name, content=file(diskconfig).read())
cursor.insert(table='diskconfig', data=data)
# here suite is a parsed xml object (find name)
def make_suite(self, suite):
current_suites = self.suitecursor.get_suites()
if suite.name not in current_suites:
apt_ids = [e.apt_id for e in suite.aptsources]
self.suitecursor.make_suite(suite.name, apt_ids)
else:
raise RuntimeError , 'suite %s already exists' % suite
# aptsources is the PaellaParser.aptsources attribute
def import_apt_sources(self, aptsources):
self.report_total_apt_sources(len(aptsources))
for apt in aptsources:
self.import_parsed_apt_source(apt)
# here apt is an AptSourceParser object
def import_parsed_apt_source(self, apt):
self.report_importing_aptsrc(apt.apt_id)
self.aptsrc.insert_apt_source_row(apt.apt_id, apt.uri, apt.dist,
apt.sections, apt.local_path)
self.aptsrc.insert_packages(apt.apt_id)
self.report_aptsrc_imported(apt.apt_id)
def _import_traits(self, suite, traitlist, dirname):
self.report_total_traits(len(traitlist))
missing = self._find_missing_packages(suite, traitlist, dirname)
if missing:
self.report_missing_packages(suite, missing)
raise MissingPackagesError, report_missing_packages(suite, missing)
else:
while len(traitlist):
trait = traitlist.pop(0)
try:
self._import_trait(suite, dirname / trait)
self.report_trait_imported(trait)
except UnbornError:
traitlist.append(trait)
# the dirname here must have the trait.xml and
# scripts and templates for the trait
def _import_trait(self, suite, dirname):
traitdb = Trait(self.conn, suite)
traitdb.insert_trait(dirname, suite)
def _find_missing_packages(self, suite, traits, dirname):
missing = dict()
traitdb = Trait(self.conn, suite)
for trait in traits:
tdir = dirname / trait
traitxml = traitdb.parse_trait_xml(tdir, suite=suite)
missing_list = traitdb.find_missing_packages(traitxml)
if missing_list:
missing[trait] = missing_list
return missing
def perform_full_import(self, dirname):
self.set_main_path(dirname)
dbdata = self.parse_main_xml()
self.start_schema()
self.import_apt_sources(dbdata.aptsources)
self.report_total_suites(len(dbdata.suites))
for suite in dbdata.suites:
self.make_suite(suite)
suitedir = self.main_path / suite.name
self._import_traits(suite.name, dbdata.get_traits(suite.name), suitedir)
self.report_suite_imported(suite.name)
self.import_all_families()
self.import_all_profiles()
self.import_all_diskconfigs()
machinedb = self.main_path / 'machine_database.xml'
if machinedb.isfile():
mh = MachineHandler(self.conn)
mh.import_machine_database(self.main_path)
default_environment_basename = 'default-environment'
filename = self.main_path / default_environment_basename
if filename.isfile():
# similar code exists in kde/environ.py
defenv = DefaultEnvironment(self.conn)
newcfg = RawConfigParser()
newcfg.read(filename)
defenv.update(newcfg)
###################
# reporting methods
####################
def report_missing_packages(self, suite, missing):
print report_missing_packages(suite, missing)
def report_total_apt_sources(self, total):
print 'importing %d apt sources' % total
def report_importing_aptsrc(self, apt_id):
print 'importing %s' % apt_id
def report_aptsrc_imported(self, apt_id):
print 'apt source %s imported' % apt_id
def report_total_suites(self, total):
print 'importing %d suites' % total
def report_importing_suite(self, suite):
print 'importing suite %s' % suite
def report_suite_imported(self, suite):
print 'suite %s imported' % suite
def report_total_traits(self, total):
print 'importing %d traits' % total
def report_importing_trait(self, trait, numtraits):
print 'importing trait', trait
def report_trait_imported(self, trait, numtraits):
print 'trait %s imported' % trait
def report_total_families(self, total):
print 'importing %d families' % total
def report_family_imported(self, family):
print 'family %s imported' % family
def report_total_profiles(self, total):
print 'importing %d profiles' % total
def report_profile_imported(self, profile):
print 'profile %s imported' % profile
class PaellaImporter(object):
def __init__(self, conn):
self.conn = conn
self.suitecursor = SuiteCursor(self.conn)
self.aptsrc = AptSourceHandler(self.conn)
self.main_path = None
self.profile = Profile(self.conn)
self.family = Family(self.conn)
def set_main_path(self, dirname):
self.main_path = path(dirname)
def parse_main_xml(self, filename=None):
if filename is None:
filename = self.main_path / 'database.xml'
parsed = PaellaParser(filename)
return parsed
def start_schema(self):
try:
start_schema(self.conn)
except AlreadyPresentError:
print "primary tables already present"
def import_all_families(self, dirname=None):
if dirname is None:
dirname = self.main_path / 'families'
xmlfiles = dirname.listdir('*.xml')
self.report_total_families(len(xmlfiles))
while xmlfiles:
familyxml = xmlfiles.pop(0)
try:
self.import_family(familyxml)
except UnbornError:
xmlfiles.append(familyxml)
print 'import families from', dirname
def import_family(self, filename):
self.family.import_family_xml(filename)
self.report_family_imported(filename.namebase)
def import_all_profiles(self, dirname=None):
if dirname is None:
dirname = self.main_path / 'profiles'
dirname = path(dirname)
xmlfiles = dirname.listdir('*.xml')
self.report_total_profiles(len(xmlfiles))
for xmlfile in xmlfiles:
self.profile.import_profile(xmlfile)
self.report_profile_imported(xmlfile.namebase)
# here suite is a parsed xml object (find name)
def make_suite(self, suite):
current_suites = self.suitecursor.get_suites()
if suite.name not in current_suites:
apt_ids = [e.apt_id for e in suite.aptsources]
self.suitecursor.make_suite(suite.name, apt_ids)
else:
raise RuntimeError, 'suite %s already exists' % suite
# aptsources is the PaellaParser.aptsources attribute
def import_apt_sources(self, aptsources):
self.report_total_apt_sources(len(aptsources))
for apt in aptsources:
self.import_parsed_apt_source(apt)
# here apt is an AptSourceParser object
def import_parsed_apt_source(self, apt):
self.report_importing_aptsrc(apt.apt_id)
self.aptsrc.insert_apt_source_row(apt.apt_id, apt.uri, apt.dist,
apt.sections, apt.local_path)
self.aptsrc.insert_packages(apt.apt_id)
self.report_aptsrc_imported(apt.apt_id)
def _import_traits(self, suite, traitlist, dirname):
self.report_total_traits(len(traitlist))
missing = self._find_missing_packages(suite, traitlist, dirname)
if missing:
self.report_missing_packages(suite, missing)
raise MissingPackagesError, report_missing_packages(suite, missing)
else:
while len(traitlist):
trait = traitlist.pop(0)
try:
self._import_trait(suite, dirname / trait)
self.report_trait_imported(trait)
except UnbornError:
traitlist.append(trait)
# the dirname here must have the trait.xml and
# scripts and templates for the trait
def _import_trait(self, suite, dirname):
traitdb = Trait(self.conn, suite)
traitdb.insert_trait(dirname, suite)
def _find_missing_packages(self, suite, traits, dirname):
missing = dict()
traitdb = Trait(self.conn, suite)
for trait in traits:
tdir = dirname / trait
traitxml = traitdb.parse_trait_xml(tdir, suite=suite)
missing_list = traitdb.find_missing_packages(traitxml)
if missing_list:
missing[trait] = missing_list
return missing
def perform_full_import(self, dirname):
self.set_main_path(dirname)
dbdata = self.parse_main_xml()
self.start_schema()
self.import_apt_sources(dbdata.aptsources)
self.report_total_suites(len(dbdata.suites))
for suite in dbdata.suites:
self.make_suite(suite)
suitedir = self.main_path / suite.name
self._import_traits(suite.name, dbdata.get_traits(suite.name), suitedir)
self.report_suite_imported(suite.name)
self.import_all_families()
self.import_all_profiles()
machinedb = self.main_path / 'machine_database.xml'
if machinedb.isfile():
mh = MachineHandler(self.conn)
mh.restore_machine_database(self.main_path)
default_environment_basename = 'default-environment'
filename = self.main_path / default_environment_basename
if filename.isfile():
# similar code exists in kde/environ.py
defenv = DefaultEnvironment(self.conn)
newcfg = RawConfigParser()
newcfg.read(filename)
defenv.update(newcfg)
def report_missing_packages(self, suite, missing):
print report_missing_packages(suite, missing)
def report_total_apt_sources(self, total):
print 'importing %d apt sources' % total
def report_importing_aptsrc(self, apt_id):
print 'importing %s' % apt_id
def report_aptsrc_imported(self, apt_id):
print 'apt source %s imported' % apt_id
def report_total_suites(self, total):
print 'importing %d suites' % total
def report_importing_suite(self, suite):
print 'importing suite %s' % suite
def report_suite_imported(self, suite):
print 'suite %s imported' % suite
def report_total_traits(self, total):
print 'importing %d traits' % total
def report_importing_trait(self, trait, numtraits):
print 'importing trait', trait
def report_trait_imported(self, trait, numtraits):
print 'trait %s imported' % trait
def report_total_families(self, total):
print 'importing %d families' % total
def report_family_imported(self, family):
print 'family %s imported' % family
def report_total_profiles(self, total):
print 'importing %d profiles' % total
def report_profile_imported(self, profile):
print 'profile %s imported' % profile