def parse_xml(self, filename):
self.dbdata = PaellaParser(filename)
self.main_path = dirname(filename)
class PaellaProcessor(object):
def __init__(self, conn, cfg=None):
object.__init__(self)
self.conn = conn
self.cfg = cfg
self.__set_cursors__()
self.main_path = None
self.suitehandler = SuiteHandler(self.conn, self.cfg)
def parse_xml(self, filename):
self.dbdata = PaellaParser(filename)
self.main_path = dirname(filename)
def start_schema(self):
start_schema(self.conn)
self._insert_aptsources()
self._sync_suites()
def _sync_suites(self):
self.main.set_table('suites')
current_suites = [row.suite for row in self.main.select()]
for suite in self.dbdata.suites:
if suite.name not in current_suites:
self.main.insert(data=suite)
for apt in suite.aptsources:
data = dict(suite=suite.name, apt_id=apt.apt_id, ord=apt.order)
self.main.insert(table='suite_apt_sources', data=data)
self.suitehandler.set_suite(suite.name)
self.suitehandler.make_suite()
#make_suite(self.main, suite.name)
#insert_packages(self.cfg, self.main, suite.name, quick=False)
else:
raise Error, '%s already exists.' % suite
#self.main.update(data=suite)
def _insert_aptsources(self):
for apt in self.dbdata.aptsources:
data = dict(apt_id=apt.apt_id, uri=apt.uri, dist=apt.dist,
sections=apt.sections, local_path=apt.local_path)
self.main.insert(table='apt_sources', data=data)
def insert_families(self):
path = join(self.main_path, 'families')
print 'path is in insert_families', path
self.family.import_families(path)
def insert_profiles(self):
path = join(self.main_path, 'profiles')
print 'path is in insert_profiles', path
xmlfiles = [join(path, x) for x in os.listdir(path) if x[-4:] == '.xml']
profiles = PaellaProfiles(self.conn)
for xmlfile in xmlfiles:
xml = parse_file(xmlfile)
elements = xml.getElementsByTagName('profile')
if len(elements) != 1:
raise Error, 'bad profile number %s' % len(elements)
element = elements[0]
parsed = ProfileParser(element)
profiles.insert_profile(parsed)
def insert_profile(self, profile):
idata = {'profile' : profile.name,
'suite' : profile.suite}
self.main.insert(table='profiles', data=idata)
idata = {'profile' : profile.name,
'trait' : None,
'ord' : 0}
for trait, ord in profile.traits:
print trait, ord
idata['trait'] = trait
idata['ord'] = ord #str(ord)
self.main.insert(table='profile_trait', data=idata)
idata = {'profile' : profile.name,
'trait' : None,
'name' : None,
'value': None}
for trait, name, value in profile.vars:
idata['trait'] = trait
idata['name'] = name
idata['value'] = value
self.main.insert(table='profile_variables', data=idata)
def insert_traits(self, suite):
self.__set_suite_cursors__(suite)
traits = [trait for trait in self.dbdata.get_traits(suite)]
self._insert_traits_(traits, suite)
def _clear_traits(self, suite):
self.__set_suite_cursors__(suite)
self.traitparent.cmd.delete()
self.traitpackage.cmd.delete()
self.main.delete(table=ujoin(suite, 'variables'))
self.traits.delete()
def _insert_traits_(self, traits, suite):
while len(traits):
trait = traits[0]
print 'inserting %s' %trait, len(traits)
try:
self._insert_trait_(trait, suite)
except UnbornError:
traits.append(trait)
del traits[0]
def _insert_trait_(self, trait, suite):
traitdb = Trait(self.conn, suite)
#path = join(self.main_path, suite, trait + '.tar')
path = join(self.main_path, suite, trait)
traitdb.insert_trait(path, suite)
def __set_cursors__(self):
self.main = StatementCursor(self.conn, 'main_paella_cursor')
self.all_traits = StatementCursor(self.conn, 'all_traits')
self.all_traits.set_table('traits')
def __set_suite_cursors__(self, suite):
self.traits = StatementCursor(self.conn, 'traits')
self.traits.set_table(ujoin(suite, 'traits'))
self.traitparent = TraitParent(self.conn, suite)
self.traitpackage = TraitPackage(self.conn, suite)
self.traittemplate = TraitTemplate(self.conn, suite)
self.family = Family(self.conn)
def create(self, filename):
self.parse_xml(filename)
self.start_schema()
for suite in self.dbdata.suites:
self.insert_traits(suite.name)
self.insert_families()
self.insert_profiles()
# use the machine handler to insert
# machine types and such
mh = MachineHandler(self.conn)
mh.restore_machine_database(self.main_path)
class PaellaProcessor(object):
def __init__(self, conn):
object.__init__(self)
self.conn = conn
self.__set_cursors__()
self.main_path = None
def parse_xml(self, filename):
self.dbdata = PaellaParser(filename)
self.main_path = dirname(filename)
def start_schema(self):
start_schema(self.conn)
self._sync_suites()
def _sync_suites(self):
self.main.set_table('suites')
current_suites = [row.suite for row in self.main.select()]
for suite in self.dbdata.suites:
if suite.name not in current_suites:
self.main.insert(data=suite)
make_suite(self.main, suite.name)
insert_packages(self.main, suite.name)
else:
self.main.update(data=suite)
def insert_profiles(self):
path = join(self.main_path, 'profiles')
print 'path is in insert_profiles', path
xmlfiles = [join(path, x) for x in os.listdir(path) if x[-4:] == '.xml']
profiles = PaellaProfiles(self.conn)
for xmlfile in xmlfiles:
xml = parse_file(xmlfile)
elements = xml.getElementsByTagName('profile')
if len(elements) != 1:
raise Error, 'bad profile number %s' % len(elements)
element = elements[0]
parsed = ProfileParser(element)
profiles.insert_profile(parsed)
def insert_profile(self, profile):
idata = {'profile' : profile.name,
'suite' : profile.suite}
self.main.insert(table='profiles', data=idata)
idata = {'profile' : profile.name,
'trait' : None,
'ord' : 0}
for trait, ord in profile.traits:
print trait, ord
idata['trait'] = trait
idata['ord'] = ord #str(ord)
self.main.insert(table='profile_trait', data=idata)
idata = {'profile' : profile.name,
'trait' : None,
'name' : None,
'value': None}
for trait, name, value in profile.vars:
idata['trait'] = trait
idata['name'] = name
idata['value'] = value
self.main.insert(table='profile_variables', data=idata)
def insert_traits(self, suite):
self.__set_suite_cursors__(suite)
traits = [trait for trait in self.dbdata.get_traits(suite)]
self._insert_traits_(traits, suite)
def _clear_traits(self, suite):
self.__set_suite_cursors__(suite)
self.traitparent.cmd.delete()
self.traitpackage.cmd.delete()
self.main.delete(table=ujoin(suite, 'variables'))
self.traits.delete()
def _insert_traits_(self, traits, suite):
while len(traits):
trait = traits[0]
print 'inserting %s' %trait, len(traits)
try:
self._insert_trait_(trait, suite)
except UnbornError:
traits.append(trait)
del traits[0]
def _insert_trait_(self, trait, suite):
traitdb = Trait(self.conn, suite)
path = join(self.main_path, suite, trait + '.tar')
traitdb.insert_trait(path, suite)
def __set_cursors__(self):
self.main = StatementCursor(self.conn, 'main_paella_cursor')
self.all_traits = StatementCursor(self.conn, 'all_traits')
self.all_traits.set_table('traits')
def __set_suite_cursors__(self, suite):
self.traits = StatementCursor(self.conn, 'traits')
self.traits.set_table(ujoin(suite, 'traits'))
self.traitparent = TraitParent(self.conn, suite)
self.traitpackage = TraitPackage(self.conn, suite)
self.traittemplate = TraitTemplate(self.conn, suite)
self.traitdebconf = TraitDebconf(self.conn, suite)
def create(self, filename):
for table in self.main.tables():
self.main.execute('drop table %s' %table)
self.parse_xml(filename)
self.start_schema()
for suite in self.dbdata.suites:
self.insert_traits(suite.name)
self.insert_profiles()
def parse_xml(self, filename):
self.dbdata = PaellaParser(filename)
self.main_path = dirname(filename)
class PaellaProcessor(object):
def __init__(self, conn):
object.__init__(self)
self.conn = conn
self.__set_cursors__()
self.main_path = None
def parse_xml(self, filename):
self.dbdata = PaellaParser(filename)
self.main_path = dirname(filename)
def start_schema(self):
start_schema(self.conn)
self._sync_suites()
def _sync_suites(self):
self.main.set_table('suites')
current_suites = [row.suite for row in self.main.select()]
for suite in self.dbdata.suites:
if suite.name not in current_suites:
self.main.insert(data=suite)
make_suite(self.main, suite.name)
insert_packages(self.main, suite.name, quick=False)
else:
self.main.update(data=suite)
def insert_families(self):
path = join(self.main_path, 'families')
print 'path is in insert_families', path
self.family.import_families(path)
def insert_profiles(self):
path = join(self.main_path, 'profiles')
print 'path is in insert_profiles', path
xmlfiles = [
join(path, x) for x in os.listdir(path) if x[-4:] == '.xml'
]
profiles = PaellaProfiles(self.conn)
for xmlfile in xmlfiles:
xml = parse_file(xmlfile)
elements = xml.getElementsByTagName('profile')
if len(elements) != 1:
raise Error, 'bad profile number %s' % len(elements)
element = elements[0]
parsed = ProfileParser(element)
profiles.insert_profile(parsed)
def insert_profile(self, profile):
idata = {'profile': profile.name, 'suite': profile.suite}
self.main.insert(table='profiles', data=idata)
idata = {'profile': profile.name, 'trait': None, 'ord': 0}
for trait, ord in profile.traits:
print trait, ord
idata['trait'] = trait
idata['ord'] = ord #str(ord)
self.main.insert(table='profile_trait', data=idata)
idata = {
'profile': profile.name,
'trait': None,
'name': None,
'value': None
}
for trait, name, value in profile.vars:
idata['trait'] = trait
idata['name'] = name
idata['value'] = value
self.main.insert(table='profile_variables', data=idata)
def insert_traits(self, suite):
self.__set_suite_cursors__(suite)
traits = [trait for trait in self.dbdata.get_traits(suite)]
self._insert_traits_(traits, suite)
def _clear_traits(self, suite):
self.__set_suite_cursors__(suite)
self.traitparent.cmd.delete()
self.traitpackage.cmd.delete()
self.main.delete(table=ujoin(suite, 'variables'))
self.traits.delete()
def _insert_traits_(self, traits, suite):
while len(traits):
trait = traits[0]
print 'inserting %s' % trait, len(traits)
try:
self._insert_trait_(trait, suite)
except UnbornError:
traits.append(trait)
del traits[0]
def _insert_trait_(self, trait, suite):
traitdb = Trait(self.conn, suite)
#path = join(self.main_path, suite, trait + '.tar')
path = join(self.main_path, suite, trait)
traitdb.insert_trait(path, suite)
def __set_cursors__(self):
self.main = StatementCursor(self.conn, 'main_paella_cursor')
self.all_traits = StatementCursor(self.conn, 'all_traits')
self.all_traits.set_table('traits')
def __set_suite_cursors__(self, suite):
self.traits = StatementCursor(self.conn, 'traits')
self.traits.set_table(ujoin(suite, 'traits'))
self.traitparent = TraitParent(self.conn, suite)
self.traitpackage = TraitPackage(self.conn, suite)
self.traittemplate = TraitTemplate(self.conn, suite)
self.traitdebconf = TraitDebconf(self.conn, suite)
self.family = Family(self.conn)
def create(self, filename):
self.parse_xml(filename)
self.start_schema()
for suite in self.dbdata.suites:
self.insert_traits(suite.name)
self.insert_families()
self.insert_profiles()
def parse_main_xml(self, filename=None):
if filename is None:
filename = self.main_path / 'database.xml'
parsed = PaellaParser(filename)
return parsed
class PaellaProcessor(object):
def __init__(self, conn, cfg=None):
object.__init__(self)
self.conn = conn
self.cfg = cfg
self.__set_cursors__()
self.main_path = None
self.suitecursor = SuiteCursor(self.conn)
self.aptsrc = AptSourceHandler(self.conn)
def parse_xml(self, filename):
self.dbdata = PaellaParser(filename)
self.main_path = os.path.dirname(filename)
def start_schema(self):
try:
start_schema(self.conn)
except AlreadyPresentError:
print "primary tables already present"
pass
def insert_apt_sources(self):
self._insert_aptsources()
def _sync_suites(self):
self.main.set_table("suites")
current_suites = [row.suite for row in self.main.select()]
for suite in self.dbdata.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 Error, "%s already exists." % suite
# self.main.update(data=suite)
def _insert_aptsources(self):
for apt in self.dbdata.aptsources:
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)
def insert_families(self):
path = os.path.join(self.main_path, "families")
print "path is in insert_families", path
self.family.import_families(path)
def insert_profiles(self):
path = os.path.join(self.main_path, "profiles")
print "path is in insert_profiles", path
xmlfiles = [os.path.join(path, x) for x in os.listdir(path) if x[-4:] == ".xml"]
profiles = PaellaProfiles(self.conn)
for xmlfile in xmlfiles:
xml = parse_file(xmlfile)
elements = xml.getElementsByTagName("profile")
if len(elements) != 1:
raise Error, "bad profile number %s" % len(elements)
element = elements[0]
parsed = ProfileParser(element)
profiles.insert_profile(parsed)
def insert_profile(self, profile):
idata = {"profile": profile.name, "suite": profile.suite}
self.main.insert(table="profiles", data=idata)
idata = {"profile": profile.name, "trait": None, "ord": 0}
for trait, ord in profile.traits:
print trait, ord
idata["trait"] = trait
idata["ord"] = ord # str(ord)
self.main.insert(table="profile_trait", data=idata)
idata = {"profile": profile.name, "trait": None, "name": None, "value": None}
for trait, name, value in profile.vars:
idata["trait"] = trait
idata["name"] = name
idata["value"] = value
self.main.insert(table="profile_variables", data=idata)
def insert_traits(self, suite):
self.__set_suite_cursors__(suite)
traits = [trait for trait in self.dbdata.get_traits(suite)]
missing = self._find_missing_packages(suite, traits)
if missing:
print "missing these packages in suite", suite
self._make_missing_packages_report(missing)
raise RuntimeError, "Missing packages declared in suite %s" % suite
else:
self._insert_traits_(traits, suite)
def _make_missing_packages_report(self, missing):
traits = missing.keys()
traits.sort()
for trait in traits:
print "%s:" % trait
for package in missing[t]:
print "\t%s" % package
def _find_missing_packages(self, suite, traits):
missing = dict()
tdb = Trait(self.conn, suite)
print suite, traits
for trait in traits:
path = self._get_trait_path(suite, trait)
traitxml = tdb.parse_trait_xml(path, suite=suite)
missing_list = tdb.find_missing_packages(traitxml)
if missing_list:
# print 'in trait,', trait, ', missing packages: ', missing_list
missing[trait] = missing_list
return missing
def _clear_traits(self, suite):
self.__set_suite_cursors__(suite)
self.traitparent.cmd.delete()
self.traitpackage.cmd.delete()
self.main.delete(table=ujoin(suite, "variables"))
self.traits.delete()
def _get_trait_path(self, suite, trait):
return os.path.join(self.main_path, suite, trait)
def _insert_traits_(self, traits, suite):
while len(traits):
trait = traits[0]
print "inserting %s" % trait, len(traits)
try:
self._insert_trait_(trait, suite)
except UnbornError:
traits.append(trait)
del traits[0]
def _insert_trait_(self, trait, suite):
traitdb = Trait(self.conn, suite)
# path = join(self.main_path, suite, trait + '.tar')
path = self._get_trait_path(suite, trait)
traitdb.insert_trait(path, suite)
def __set_cursors__(self):
self.main = StatementCursor(self.conn, "main_paella_cursor")
self.all_traits = StatementCursor(self.conn, "all_traits")
self.all_traits.set_table("traits")
def __set_suite_cursors__(self, suite):
self.traits = StatementCursor(self.conn, "traits")
self.traits.set_table(ujoin(suite, "traits"))
self.traitparent = TraitParent(self.conn, suite)
self.traitpackage = TraitPackage(self.conn, suite)
self.traittemplate = TraitTemplate(self.conn, suite)
self.family = Family(self.conn)
def create(self, filename):
self.parse_xml(filename)
self.start_schema()
self.insert_apt_sources()
self._sync_suites()
for suite in self.dbdata.suites:
self.insert_traits(suite.name)
self.insert_families()
self.insert_profiles()
# use the machine handler to insert
# machine types and such
if os.path.isfile(os.path.join(self.main_path, "machine_database.xml")):
mh = MachineHandler(self.conn)
mh.restore_machine_database(self.main_path)
class PaellaProcessor(object):
def __init__(self, conn, cfg=None):
object.__init__(self)
self.conn = conn
self.cfg = cfg
self.__set_cursors__()
self.main_path = None
self.suitecursor = SuiteCursor(self.conn)
self.aptsrc = AptSourceHandler(self.conn)
def parse_xml(self, filename):
self.dbdata = PaellaParser(filename)
self.main_path = os.path.dirname(filename)
def start_schema(self):
try:
start_schema(self.conn)
except AlreadyPresentError:
print "primary tables already present"
pass
def insert_apt_sources(self):
self._insert_aptsources()
def _sync_suites(self):
self.main.set_table('suites')
current_suites = [row.suite for row in self.main.select()]
for suite in self.dbdata.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 Error, '%s already exists.' % suite
#self.main.update(data=suite)
def _insert_aptsources(self):
for apt in self.dbdata.aptsources:
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)
def insert_families(self):
path = os.path.join(self.main_path, 'families')
print 'path is in insert_families', path
self.family.import_families(path)
def insert_profiles(self):
path = os.path.join(self.main_path, 'profiles')
print 'path is in insert_profiles', path
xmlfiles = [os.path.join(path, x) for x in os.listdir(path) if x[-4:] == '.xml']
profiles = PaellaProfiles(self.conn)
for xmlfile in xmlfiles:
xml = parse_file(xmlfile)
elements = xml.getElementsByTagName('profile')
if len(elements) != 1:
raise Error, 'bad profile number %s' % len(elements)
element = elements[0]
parsed = ProfileParser(element)
profiles.insert_profile(parsed)
def insert_profile(self, profile):
idata = {'profile' : profile.name,
'suite' : profile.suite}
self.main.insert(table='profiles', data=idata)
idata = {'profile' : profile.name,
'trait' : None,
'ord' : 0}
for trait, ord in profile.traits:
print trait, ord
idata['trait'] = trait
idata['ord'] = ord #str(ord)
self.main.insert(table='profile_trait', data=idata)
idata = {'profile' : profile.name,
'trait' : None,
'name' : None,
'value': None}
for trait, name, value in profile.vars:
idata['trait'] = trait
idata['name'] = name
idata['value'] = value
self.main.insert(table='profile_variables', data=idata)
def insert_traits(self, suite):
self.__set_suite_cursors__(suite)
traits = [trait for trait in self.dbdata.get_traits(suite)]
missing = self._find_missing_packages(suite, traits)
if missing:
print 'missing these packages in suite', suite
self._make_missing_packages_report(missing)
raise RuntimeError, 'Missing packages declared in suite %s' % suite
else:
self._insert_traits_(traits, suite)
def _make_missing_packages_report(self, missing):
traits = missing.keys()
traits.sort()
for trait in traits:
print '%s:' % trait
for package in missing[t]:
print '\t%s' % package
def _find_missing_packages(self, suite, traits):
missing = dict()
tdb = Trait(self.conn, suite)
print suite, traits
for trait in traits:
path = self._get_trait_path(suite, trait)
traitxml = tdb.parse_trait_xml(path, suite=suite)
missing_list = tdb.find_missing_packages(traitxml)
if missing_list:
#print 'in trait,', trait, ', missing packages: ', missing_list
missing[trait] = missing_list
return missing
def _clear_traits(self, suite):
self.__set_suite_cursors__(suite)
self.traitparent.cmd.delete()
self.traitpackage.cmd.delete()
self.main.delete(table=ujoin(suite, 'variables'))
self.traits.delete()
def _get_trait_path(self, suite, trait):
return os.path.join(self.main_path, suite, trait)
def _insert_traits_(self, traits, suite):
while len(traits):
trait = traits[0]
print 'inserting %s' % trait, len(traits)
try:
self._insert_trait_(trait, suite)
except UnbornError:
traits.append(trait)
del traits[0]
def _insert_trait_(self, trait, suite):
traitdb = Trait(self.conn, suite)
#path = join(self.main_path, suite, trait + '.tar')
path = self._get_trait_path(suite, trait)
traitdb.insert_trait(path, suite)
def __set_cursors__(self):
self.main = StatementCursor(self.conn, 'main_paella_cursor')
self.all_traits = StatementCursor(self.conn, 'all_traits')
self.all_traits.set_table('traits')
def __set_suite_cursors__(self, suite):
self.traits = StatementCursor(self.conn, 'traits')
self.traits.set_table(ujoin(suite, 'traits'))
self.traitparent = TraitParent(self.conn, suite)
self.traitpackage = TraitPackage(self.conn, suite)
self.traittemplate = TraitTemplate(self.conn, suite)
self.family = Family(self.conn)
def create(self, filename):
self.parse_xml(filename)
self.start_schema()
self.insert_apt_sources()
self._sync_suites()
for suite in self.dbdata.suites:
self.insert_traits(suite.name)
self.insert_families()
self.insert_profiles()
# use the machine handler to insert
# machine types and such
if os.path.isfile(os.path.join(self.main_path, 'machine_database.xml')):
mh = MachineHandler(self.conn)
mh.restore_machine_database(self.main_path)