import os
import psycopg2
+import psycopg2.extras
import traceback
from singleton import Singleton
'suite_version': Cache(lambda x: '%s_%s' % (x['source'], x['suite'])),
}
+ self.prepared_statements = {}
+
+ def prepare(self,name,statement):
+ if not self.prepared_statements.has_key(name):
+ c = self.cursor()
+ c.execute(statement)
+ self.prepared_statements[name] = statement
+
def clear_caches(self):
self.__init_caches()
return self.db_con.commit()
## Get functions
+ def __get_single_row(self, query, values):
+ c = self.db_con.cursor(cursor_factory=psycopg2.extras.DictCursor)
+ c.execute(query, values)
+
+ if c.rowcount < 1:
+ return None
+
+ res = c.fetchone()
+
+ return res
+
def __get_single_id(self, query, values, cachename=None):
# This is a bit of a hack but it's an internal function only
if cachename is not None:
@return: the database id for the given suite
"""
- return self.__get_id('id', 'suite', 'suite_name', suite)
+ return int(self.__get_id('id', 'suite', 'suite_name', suite))
def get_section_id(self, section):
"""
@return: the database id for the given override type
"""
- return self.__get_id('id', 'override_type', 'override_type', override_type)
+ return self.__get_id('id', 'override_type', 'type', override_type)
def get_architecture_id(self, architecture):
"""
return self.__get_single_id("SELECT id FROM source s WHERE s.source=%(source)s AND s.version=%(version)s",
{'source': source, 'version': version}, cachename='source')
+ def get_suite(self, suite):
+ if isinstance(suite, str):
+ suite_id = self.get_suite_id(suite.lower())
+ elif type(suite) == int:
+ suite_id = suite
+
+ return self.__get_single_row("SELECT * FROM suite WHERE id = %(id)s",
+ {'id': suite_id})
+
def get_suite_version(self, source, suite):
"""
Returns database id for a combination of C{source} and C{suite}.
else:
row = cursor.fetchone()
- if row[1] != size or row[2] != md5sum:
+ if row[1] != int(size) or row[2] != md5sum:
res = -2
else:
- self.caches[cachename].SetValue(values, row[0])
+ self.caches['files'].SetValue(values, row[0])
res = row[0]
return res
@rtype: int
@return: the database id for the given component
"""
- values={'value': filename}
- query = "SELECT id FROM content_file_names WHERE file = %(value)s"
- id = self.__get_single_id(query, values, cachename='content_file_names')
- if not id:
- c = self.db_con.cursor()
- c.execute( "INSERT INTO content_file_names VALUES (DEFAULT, %(value)s) RETURNING id",
- values )
-
- id = c.fetchone()[0]
- self.caches['content_file_names'].SetValue(values, id)
-
- return id
+ try:
+ values={'value': filename}
+ query = "SELECT id FROM content_file_names WHERE file = %(value)s"
+ id = self.__get_single_id(query, values, cachename='content_file_names')
+ if not id:
+ c = self.db_con.cursor()
+ c.execute( "INSERT INTO content_file_names VALUES (DEFAULT, %(value)s) RETURNING id",
+ values )
+
+ id = c.fetchone()[0]
+ self.caches['content_file_names'].SetValue(values, id)
+
+ return id
+ except:
+ traceback.print_exc()
+ raise
def get_or_set_contents_path_id(self, path):
"""
@rtype: int
@return: the database id for the given component
"""
- values={'value': path}
- query = "SELECT id FROM content_file_paths WHERE path = %(value)s"
- id = self.__get_single_id(query, values, cachename='content_path_names')
- if not id:
- c = self.db_con.cursor()
- c.execute( "INSERT INTO content_file_paths VALUES (DEFAULT, %(value)s) RETURNING id",
- values )
-
- id = c.fetchone()[0]
- self.caches['content_path_names'].SetValue(values, id)
-
- return id
+ try:
+ values={'value': path}
+ query = "SELECT id FROM content_file_paths WHERE path = %(value)s"
+ id = self.__get_single_id(query, values, cachename='content_path_names')
+ if not id:
+ c = self.db_con.cursor()
+ c.execute( "INSERT INTO content_file_paths VALUES (DEFAULT, %(value)s) RETURNING id",
+ values )
+
+ id = c.fetchone()[0]
+ self.caches['content_path_names'].SetValue(values, id)
+
+ return id
+ except:
+ traceback.print_exc()
+ raise
def get_suite_architectures(self, suite):
"""
c.execute("BEGIN WORK")
try:
+ arch_id = self.get_architecture_id(package['Architecture'])
- # Remove any already existing recorded files for this package
+ # Remove any already existing recorded files for this package
c.execute("""DELETE FROM pending_content_associations
WHERE package=%(Package)s
- AND version=%(Version)s""", package )
+ AND version=%(Version)s
+ AND architecture=%(ArchID)s""", {'Package': package['Package'],
+ 'Version': package['Version'],
+ 'ArchID': arch_id})
for fullpath in fullpaths:
(path, file) = os.path.split(fullpath)
+ if path.startswith( "./" ):
+ path = path[2:]
# Get the necessary IDs ...
file_id = self.get_or_set_contents_file_id(file)
path_id = self.get_or_set_contents_path_id(path)
c.execute("""INSERT INTO pending_content_associations
- (package, version, filepath, filename)
- VALUES (%%(Package)s, %%(Version)s, '%d', '%d')""" % (path_id, file_id),
- package )
+ (package, version, architecture, filepath, filename)
+ VALUES (%%(Package)s, %%(Version)s, '%d', '%d', '%d')"""
+ % (arch_id, path_id, file_id), package )
+
c.execute("COMMIT")
return True
except:
traceback.print_exc()
c.execute("ROLLBACK")
return False
+
+################################################################################
+
+class Suite(object):
+ # This should be kept in sync with the suites table;
+ # we should probably just do introspection on the table
+ # (or maybe use an ORM)
+ _fieldnames = ['announce', 'changelogbase', 'codename', 'commentsdir',
+ 'copychanges', 'copydotdak', 'description', 'id',
+ 'label', 'notautomatic', 'origin', 'overridecodename',
+ 'overridesuite', 'policy_engine', 'priority', 'suite_name',
+ 'untouchable', 'validtime', 'version']
+
+ def __init_fields(self):
+ for k in self._fieldnames:
+ setattr(self, k, None)
+
+ def __init__(self, suite):
+ self.__init_fields()
+ if suite is not None:
+ db_conn = DBConn()
+ suite_data = db_conn.get_suite(suite)
+ if suite_data is not None:
+ for k in suite_data.keys():
+ setattr(self, k, suite_data[k])
+
+
+
projects / dak.git / blobdiff