class PaellaProfiles(Element):
def __init__(self, conn):
Element.__init__(self, 'profiles')
self.conn = conn
self.stmt = StatementCursor(self.conn)
self.env = ProfileEnvironment(self.conn)
self.profiletraits = ProfileTrait(self.conn)
self._profiles = {}
for row in self.stmt.select(table='profiles', order='profile'):
self._append_profile(row.profile, row.suite)
def _append_profile(self, profile, suite):
element = self.export_profile(profile, suite)
self._profiles[profile] = element
self.appendChild(self._profiles[profile])
def export_profile(self, profile, suite=None):
if suite is None:
row = self.stmt.select_row(table='profiles',clause=Eq('profile', profile))
suite = row['suite']
suite = str(suite)
profile = str(profile)
self.env.set_profile(profile)
element = ProfileElement(profile, suite)
element.append_traits(self.profiletraits.trait_rows(profile))
element.append_variables(self.env.get_rows())
return element
def insert_profile(self, profile):
idata = {'profile' : profile.name,
'suite' : profile.suite}
self.stmt.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.stmt.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.stmt.insert(table='profile_variables', data=idata)
def export_profiles(self, path):
rows = self.stmt.select(fields='profile', table='profiles', clause=None)
for row in rows:
self.write_profile(row.profile, path)
def write_profile(self, profile, path):
xmlfile = file(join(path, '%s.xml' % profile), 'w')
data = self.export_profile(profile)
data.writexml(xmlfile, indent='\t', newl='\n', addindent='\t')
xmlfile.close()
class TextFileManager(object):
def __init__(self, conn):
object.__init__(self)
self.conn = conn
self.cursor = StatementCursor(self.conn)
self.cursor.set_table('textfiles')
def insert_file(self, datafile):
md5 = self._md5sum(datafile)
data = datafile.read()
md5size = '_'.join([md5, str(len(data))])
return self._insert_data(md5size, data)
def insert_data(self, data):
md5 = md5sum(strfile(data))
md5size = '_'.join([md5, str(len(data))])
return self._insert_data(md5size, data)
def _insert_data(self, md5size, data):
clause=Eq('md5size', md5size)
try:
row = self.cursor.select_row(clause=clause)
except NoExistError:
row = None
if not row:
self.cursor.insert(data={'md5size' : md5size, 'data' : data})
row = self.cursor.select_row(clause=clause)
return row.fileid
def get_data(self, id):
row = self.cursor.select_row(clause=Eq('fileid', id))
return row.data
def get_strfile(self, id):
return strfile(self.get_data(id))
def _md5sum(self, datafile):
datafile.seek(0)
md5 = md5sum(datafile)
datafile.seek(0)
return md5
class TextFileManager(object):
def __init__(self, conn):
object.__init__(self)
self.conn = conn
self.cursor = StatementCursor(self.conn)
self.cursor.set_table('textfiles')
def insert_file(self, datafile):
md5 = self._md5sum(datafile)
data = datafile.read()
md5size = '_'.join([md5, str(len(data))])
return self._insert_data(md5size, data)
def insert_data(self, data):
md5 = md5sum(strfile(data))
md5size = '_'.join([md5, str(len(data))])
return self._insert_data(md5size, data)
def _insert_data(self, md5size, data):
clause = Eq('md5size', md5size)
try:
row = self.cursor.select_row(clause=clause)
except NoExistError:
row = None
if not row:
self.cursor.insert(data={'md5size': md5size, 'data': data})
row = self.cursor.select_row(clause=clause)
return row.fileid
def get_data(self, id):
row = self.cursor.select_row(clause=Eq('fileid', id))
return row.data
def get_strfile(self, id):
return strfile(self.get_data(id))
def _md5sum(self, datafile):
datafile.seek(0)
md5 = md5sum(datafile)
datafile.seek(0)
return md5
class PaellaProfiles(Element):
def __init__(self, conn):
Element.__init__(self, 'profiles')
self.conn = conn
self.stmt = StatementCursor(self.conn)
self.env = ProfileEnvironment(self.conn)
self.profiletraits = ProfileTrait(self.conn)
self._profiles = {}
self._profile = Profile(self.conn)
for row in self.stmt.select(table='profiles', order='profile'):
self._append_profile(row.profile, row.suite)
def _append_profile(self, profile, suite):
element = self.export_profile(profile, suite)
self._profiles[profile] = element
self.appendChild(self._profiles[profile])
def export_profile(self, profile, suite=None):
if suite is None:
row = self.stmt.select_row(table='profiles',
clause=Eq('profile', profile))
suite = row['suite']
suite = str(suite)
profile = str(profile)
self.env.set_profile(profile)
element = ProfileElement(profile, suite)
element.append_traits(self.profiletraits.trait_rows(profile))
element.append_families(self._profile.family_rows(profile))
element.append_variables(self.env.get_rows())
return element
def insert_profile(self, profile):
idata = {'profile': profile.name, 'suite': profile.suite}
self.stmt.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.stmt.insert(table='profile_trait', data=idata)
idata = {
'profile': profile.name,
'trait': None,
'name': None,
'value': None
}
idata = dict(profile=profile.name)
for family in profile.families:
idata['family'] = family
self.stmt.insert(table='profile_family', data=idata)
idata = dict(profile=profile.name)
for trait, name, value in profile.vars:
idata['trait'] = trait
idata['name'] = name
idata['value'] = value
self.stmt.insert(table='profile_variables', data=idata)
def export_profiles(self, path):
rows = self.stmt.select(fields='profile',
table='profiles',
clause=None)
for row in rows:
self.write_profile(row.profile, path)
def write_profile(self, profile, path):
xmlfile = file(join(path, '%s.xml' % profile), 'w')
data = self.export_profile(profile)
data.writexml(xmlfile, indent='\t', newl='\n', addindent='\t')
xmlfile.close()
class BaseDatabase(QSqlDatabase):
def __init__(self, dsn, name, parent=None, objname=None):
QSqlDatabase.__init__(self, "QPSQL7", name, parent, objname)
self.conn = BasicConnection(**dsn)
self.setDatabaseName(dsn["dbname"])
self.setHostName(dsn["host"])
self.dbuser = dsn["user"]
self.setUserName(self.dbuser)
self.stmt = Statement()
self.mcursor = StatementCursor(self.conn)
def set_table(self, table):
self.stmt.table = table
def set_clause(self, items, cmp="=", join="and"):
self.stmt.set_clause(items, cmp=cmp, join=join)
def set_data(self, data):
self.stmt.set(data)
def set_fields(self, fields):
self.stmt.fields = fields
def qdelete(self, table=None, clause=None):
query = self.stmt.delete(table=table, clause=clause)
return self.execStatement(query)
def qinsert(self, table=None, data=None):
query = self.stmt.insert(table=table, data=data)
return self.execStatement(query)
def qupdate(self, table=None, data=None, clause=None):
query = self.stmt.update(table=table, data=data, clause=clause)
return self.execStatement(query)
def qselect(self, fields=None, table=None, clause=None, group=None, having=None, order=None):
query = self.stmt.select(fields=fields, table=table, clause=clause, group=group, having=having, order=order)
return self.execStatement(query)
def delete(self, table=None, clause=None):
query = self.stmt.delete(table=table, clause=clause)
return self.mcursor.execute(query)
def insert(self, table=None, data=None):
query = self.stmt.insert(table=table, data=data)
return self.mcursor.execute(query)
def update(self, table=None, data=None, clause=None):
query = self.stmt.update(table=table, data=data, clause=clause)
return self.mcursor.execute(query)
def select(self, fields=None, table=None, clause=None, group=None, having=None, order=None):
query = self.stmt.select(fields=fields, table=table, clause=clause, group=group, having=having, order=order)
self.mcursor.execute(query)
return self.mcursor.fetchall()
def select_row(self, fields=None, table=None, clause=None, group=None, having=None, order=None):
query = self.stmt.select(fields=fields, table=table, clause=clause, group=group, having=having, order=order)
self.mcursor.execute(query)
rows = len(self.mcursor)
if rows == 1:
return self.mcursor.next()
elif rows == 0:
raise NoExistError
else:
raise Error, "bad row count %s" % rows
def clear(self, **args):
self.stmt.clear(**args)
def stdclause(self, data):
return reduce(and_, [Eq(k, v) for k, v in data.items()])
def insertData(self, idcol, table, data, commit=True):
clause = self.stdclause(data)
try:
self.mcursor.select_row(fields=[idcol], table=table, clause=clause)
except NoExistError:
self.mcursor.insert(table=table, data=data)
if commit:
self.conn.commit()
def identifyData(self, idcol, table, data, commit=True):
clause = self.stdclause(data)
self.insertData(idcol, table, data, commit=commit)
return self.mcursor.select_row(fields=["*"], table=table, clause=clause)
class RepositoryManager(object):
def __init__(self, conn):
self.conn = conn
self.main = StatementCursor(self.conn, 'RepositoryMain')
self.repos = StatementCursor(self.conn, 'Repository')
self.repos.set_table('repository')
self.sources = StatementCursor(self.conn, 'Sources')
self.sources.set_table('sources')
self.release = ReleaseCursor(self.conn)
self.repsections = StatementCursor(self.conn, 'repos_section')
self.repsections.set_table('repos_section')
self.__init_db__()
def __init_db__(self):
if not len(self.main.tables()):
map(self.main.create_table, primary_tables())
def drop_source(self, name, type):
nameclause = Eq('name', name)
clause = nameclause & Eq('type', type)
for section in self.get_sections(name):
self.main.drop(list_tablename(name, type, section))
self.sources.delete(clause=clause)
sources = self.sources.select(clause=clause)
if not len(sources):
self.repsections.delete(clause=nameclause)
self.repos.delete(clause=nameclause)
def add_source(self, name, source):
source = make_source(source)
if name not in [x.name for x in self.repos.select()]:
self.repos.insert(data=dict(name=name))
clause = Eq('name', name) & Eq('type', source.type)
count = int(
self.sources.select(fields=['count(name)'], clause=clause)[0][0])
if count == 0:
if islocaluri(source.uri):
data = dict(name=name,
type=source.type,
uri=source.uri,
suite=source.suite)
self.sources.insert(data=data)
current_sections = self.get_sections(name)
sdata = dict(name=name, section=None)
for section in source.sections:
if section not in current_sections:
sdata['section'] = section
self.repsections.insert(data=sdata)
fullparse = FullParseTable(name, source.type, section)
if fullparse.name not in self.main.tables():
self.main.create_table(fullparse)
listtable = ListTable(name, source.type, section)
if listtable.name not in self.main.tables():
self.main.create_table(listtable)
else:
raise Error, 'local uris first'
else:
if not islocaluri(source.uri):
data = dict(remote=source.uri)
self.sources.update(data=data, clause=clause)
else:
raise ExistsError, 'already there'
def get_sections(self, name):
clause = Eq('name', name)
return [
x.section for x in self.repsections.iselect(fields=['section'],
clause=clause)
]
def make_source_line(self, name, type, remote=False):
repsrc = self.make_source(name, type, remote)
return str(repsrc)
def make_source(self, name, type, remote=False):
clause = Eq('name', name) & Eq('type', type)
source = self.sources.select_row(clause=clause)
repsrc = RepositorySource()
repsrc.type = source.type
if remote:
repsrc.uri = source.remote
else:
repsrc.uri = source.uri
repsrc.suite = source.suite
repsrc.sections = self.get_sections(name)
repsrc.set_path()
return repsrc
def listfile(self, name, type, section=None):
source = self.make_source(name, type)
release = Release(source)
print 'Need to pull from database!!!'
if source.has_release():
return join(source.distpath, release.path(section))
else:
return join(source.distpath, source.listfile())
def get_remote(self, name, type, remote=True):
return self.make_source(name, type, remote=True)
def parse_section(self, name, type, section=None):
listfile = self.listfile(name, type, section)
debug(listfile)
if not isfile(listfile):
raise NoFileError, 'file not there'
if type == 'deb':
return full_parse(listfile)
elif type == 'deb-src':
return parse_sources(listfile)
else:
raise Error, 'bad source type'
def add_repository(self, name):
self.repos.insert(data=dict(name=name))
class RepositoryManager(object):
def __init__(self, conn):
self.conn = conn
self.main = StatementCursor(self.conn, 'RepositoryMain')
self.repos = StatementCursor(self.conn, 'Repository')
self.repos.set_table('repository')
self.sources = StatementCursor(self.conn, 'Sources')
self.sources.set_table('sources')
self.release = ReleaseCursor(self.conn)
self.repsections = StatementCursor(self.conn, 'repos_section')
self.repsections.set_table('repos_section')
self.__init_db__()
def __init_db__(self):
if not len(self.main.tables()):
map(self.main.create_table, primary_tables())
def drop_source(self, name, type):
nameclause = Eq('name', name)
clause = nameclause & Eq('type', type)
for section in self.get_sections(name):
self.main.drop(list_tablename(name, type, section))
self.sources.delete(clause=clause)
sources = self.sources.select(clause=clause)
if not len(sources):
self.repsections.delete(clause=nameclause)
self.repos.delete(clause=nameclause)
def add_source(self, name, source):
source = make_source(source)
if name not in [x.name for x in self.repos.select()]:
self.repos.insert(data=dict(name=name))
clause = Eq('name', name) & Eq('type', source.type)
count = int(self.sources.select(fields=['count(name)'], clause=clause)[0][0])
if count == 0:
if islocaluri(source.uri):
data = dict(name=name, type=source.type, uri=source.uri,
suite=source.suite)
self.sources.insert(data=data)
current_sections = self.get_sections(name)
sdata = dict(name=name, section=None)
for section in source.sections:
if section not in current_sections:
sdata['section'] = section
self.repsections.insert(data=sdata)
fullparse = FullParseTable(name, source.type, section)
if fullparse.name not in self.main.tables():
self.main.create_table(fullparse)
listtable = ListTable(name, source.type, section)
if listtable.name not in self.main.tables():
self.main.create_table(listtable)
else:
raise Error, 'local uris first'
else:
if not islocaluri(source.uri):
data = dict(remote=source.uri)
self.sources.update(data=data, clause=clause)
else:
raise ExistsError, 'already there'
def get_sections(self, name):
clause = Eq('name', name)
return [x.section for x in self.repsections.iselect(fields=['section'], clause=clause)]
def make_source_line(self, name, type, remote=False):
repsrc = self.make_source(name, type, remote)
return str(repsrc)
def make_source(self, name, type, remote=False):
clause = Eq('name', name) & Eq('type', type)
source = self.sources.select_row(clause=clause)
repsrc = RepositorySource()
repsrc.type = source.type
if remote:
repsrc.uri = source.remote
else:
repsrc.uri = source.uri
repsrc.suite = source.suite
repsrc.sections = self.get_sections(name)
repsrc.set_path()
return repsrc
def listfile(self, name, type, section=None):
source = self.make_source(name, type)
release = Release(source)
print 'Need to pull from database!!!'
if source.has_release():
return join(source.distpath, release.path(section))
else:
return join(source.distpath, source.listfile())
def get_remote(self, name, type, remote=True):
return self.make_source(name, type, remote=True)
def parse_section(self, name, type, section=None):
listfile = self.listfile(name, type, section)
debug(listfile)
if not isfile(listfile):
raise NoFileError, 'file not there'
if type == 'deb':
return full_parse(listfile)
elif type == 'deb-src':
return parse_sources(listfile)
else:
raise Error, 'bad source type'
def add_repository(self, name):
self.repos.insert(data=dict(name=name))
