[gentoo-commits] dev/zorry:master commit in: buildhost/buildhost/

["Magnus Granberg" <zorry@gentoo.org>]

commit:     eb3545e879aa0e58faec627167e5ec507423ba27
Author:     Magnus Granberg <zorry <AT> gentoo <DOT> org>
AuthorDate: Fri Apr  1 15:23:35 2011 +0000
Commit:     Magnus Granberg <zorry <AT> gentoo <DOT> org>
CommitDate: Fri Apr  1 15:23:35 2011 +0000
URL:        http://git.overlays.gentoo.org/gitweb/?p=dev/zorry.git;a=commit;h=eb3545e8

added the guest code

---
 buildhost/buildhost/core.py       |  323 ++++++++++++++-----
 buildhost/buildhost/sqlbackend.py |  636 +++++++++++++++++++++++++++++++++----
 2 files changed, 813 insertions(+), 146 deletions(-)

diff --git a/buildhost/buildhost/__init__.py b/buildhost/buildhost/__init__.py
new file mode 100644
index 0000000..e69de29

diff --git a/buildhost/buildhost/core.py b/buildhost/buildhost/core.py
index 6740e86..bbe23b6 100644
--- a/buildhost/buildhost/core.py
+++ b/buildhost/buildhost/core.py
@@ -4,11 +4,18 @@
 
 """core module"""
 import sys
+from StringIO import StringIO
 import os
 import re
 import portage
+from _emerge.actions import load_emerge_config
+from _emerge.main import parse_opts, emerge_main
+from _emerge.depgraph import backtrack_depgraph, depgraph, resume_depgraph
+from _emerge.create_depgraph_params import create_depgraph_params
+import _emerge
 import hashlib
 import errno
+import time
 from xml.etree.ElementTree import ElementTree
 
 class get_conf_settings(object):
@@ -49,9 +56,9 @@ def init_sql_backend():
   database = None
   
   # Setup the database backent to use mysql
-  if DatabaseConfig.mode == 'mysql':
-   from sqlbackend import MySQLPackageDB
-   database = MySQLPackageDB(DatabaseConfig.settings['sql_mysql'])
+  if DatabaseConfig.mode == 'pgsql':
+   from sqlbackend import PgSQLPackageDB
+   database = PgSQLPackageDB(DatabaseConfig.settings['sql_pgsql'])
   return database
 
 def  get_file_text(filename):
@@ -69,17 +76,17 @@ def  get_file_text(filename):
   textfile.close()
   return text
 
-def check_make_conf(database):
-  if database.get_config_active(get_conf_settings.SetBuildConfig) is None:
-     return False
+def check_make_conf(database, config_profile):
+  make_conf_checksum_db = database.get_default_config(config_profile)[0]
+  if make_conf_checksum_db is None:
+     return "1"
   make_conf_file = "/etc/make.conf"
     # Check if we can open the file and close it
     # Check if we have some error in the file (portage.util.getconfig)
     # Check if we envorment error with the config (settings.validate)
-  make_conf_checksum_db = database.get_make_conf_checksum_db(get_conf_settings.SetBuildConfig)
-  make_conf_checksum_tree = portage.checksum.sha256hash(make_conf_file)
-  if make_conf_checksum_db is None or make_conf_checksum_tree[0] != make_conf_checksum_db[0]:
-    return True
+  make_conf_checksum_tree = portage.checksum.sha256hash(make_conf_file)[0]
+  if make_conf_checksum_tree != make_conf_checksum_db:
+    return "2"
   # Check if we can open the file and close it
   # Check if we have some error in the file (portage.util.getconfig)
   # Check if we envorment error with the config (settings.validate)
@@ -91,8 +98,8 @@ def check_make_conf(database):
     portage.settings.validate()
     # With errors we return false
   except Exception as e:
-    return False
-  return True
+    return "3"
+  return "4"
 
 def get_iuse(portdb, cpv):
 	"""Gets the current IUSE flags from the tree
@@ -209,86 +216,228 @@ def get_flags(settings, portdb, cpv):
 	#flags = filter_flags(use_flags, use_expand_hidden, usemasked, useforced)
 	final_flags = filter_flags(settings, final_use, use_expand_hidden, usemasked, useforced)
 	return iuse_flags, final_flags
-def build_package(database):
-  build_list = get_package_to_build(database, get_conf_settings.SetBuildConfig)
 
+def check_configure(database, config_profile):
+  pass_make_conf = check_make_conf(database, config_profile)
+  print pass_make_conf
+  if pass_make_conf == "1":
+    # profile not active or updatedb is runing
+    return False
+  elif pass_make_conf == "2":
+    #  update make.conf
+    return False
+  elif pass_make_conf == "3":
+    # set the config as no working
+    database.make_conf_error(config_profile)
+    return False
+  elif pass_make_conf == "4":
+    # make.conf check OK
+    return True
+
+def check_file_in_manifest(pkgdir, settings, portdb, cpv, build_dict, build_use_flags_list):
+  myfetchlistdict = portage.FetchlistDict(pkgdir, settings, portdb)
+  my_manifest = portage.Manifest(pkgdir, settings['DISTDIR'], fetchlist_dict=myfetchlistdict, manifest1_compat=False, from_scratch=False)
+  if my_manifest.findFile(build_dict['package'] + "-" + build_dict['ebuild_version'] + ".ebuild") is None:
+    return False
+  cpv_fetchmap = portdb.getFetchMap(cpv, useflags=build_use_flags_list, mytree=None)
+  settings.unlock()
+  try:  
+    portage.fetch(cpv_fetchmap, settings, listonly=0, fetchonly=0, locks_in_subdir='.locks', use_locks=1, try_mirrors=1)
+  except:
+    settings.lock()
+    return False
+  settings.lock()
+  if my_manifest.checkCpvHashes(cpv, checkDistfiles=True, onlyDistfiles=False, checkMiscfiles=True) is not None:
+    return False
+  if portdb.fetch_check(cpv, useflags=build_use_flags_list, mysettings=settings, all=False) is not True:
+    return False
+  return True
+
+def get_needed_dep_useflags(cpv, build_use_flags_list):
+  tmpcmdline = []
+  tmpcmdline.append("-p")
+  tmpcmdline.append("--autounmask")
+  tmpcmdline.append("=" + cpv)
+  print tmpcmdline
+  myaction, myopts, myfiles = parse_opts(tmpcmdline, silent=False)
+  print myaction, myopts, myfiles
+  myparams = create_depgraph_params(myopts, myaction)
+  print myparams
+  settings, trees, mtimedb = load_emerge_config()
+  try:
+    success, mydepgraph, favorites = backtrack_depgraph(
+	settings, trees, myopts, myparams, myaction, myfiles, spinner=None)
+    print  success, mydepgraph, favorites
+  except portage.exception.PackageSetNotFound as e:
+	root_config = trees[settings["ROOT"]]["root_config"]
+	display_missing_pkg_set(root_config, e.value)
+	return 1
+  use_changes = None
+  mydepgraph._show_merge_list()
+  mydepgraph.display_problems()
+  if mydepgraph._dynamic_config._needed_use_config_changes:
+      use_changes = {}
+      for pkg, needed_use_config_changes in mydepgraph._dynamic_config._needed_use_config_changes.items():
+	new_use, changes = needed_use_config_changes
+	use_changes[pkg.cpv] = changes
+  print use_changes
+  if use_changes is None:
+    return None
+  iteritems_packages = {}
+  for k, v in use_changes.iteritems():
+    k_package = portage.versions.cpv_getkey(k)
+    iteritems_packages[ k_package ] = v
+  print iteritems_packages
+  return iteritems_packages
+  
+def comper_useflags(settings, portdb, cpv, build_dict):
+  iuse_flags, use_enable = get_flags(settings, portdb, cpv)
+  iuse = []
+  print "use_enable", use_enable
+  build_use_flags_dict = build_dict['build_useflags']
+  print "build_use_flags_dict", build_use_flags_dict
+  build_use_flags_list = []
+  if use_enable == []:
+    if build_use_flags_dict is None:
+      return None
+  for iuse_line in iuse_flags:
+    iuse.append(reduce_flag(iuse_line))
+  iuse_flags_list = list(set(iuse))
+  use_disable = list(set(iuse_flags_list).difference(set(use_enable)))
+  use_flagsDict = {}
+  for x in use_enable:
+    use_flagsDict[x] = True
+  for x in use_disable:
+    use_flagsDict[x] = False
+  print "use_flagsDict", use_flagsDict
+  for k, v in use_flagsDict.iteritems():
+    print "tree use flags", k, v
+    print "db use flags", k, build_use_flags_dict[k]
+  if build_use_flags_dict[k] != v:
+    if build_use_flags_dict[k] is True:
+      build_use_flags_list.append(k)
+    if build_use_flags_dict[k] is False:
+      build_use_flags_list.append("-" + k)
+  if build_use_flags_list == []:
+    build_use_flags_list = None
+  print build_use_flags_list
+  return build_use_flags_list
+
+def get_cpv_build_list(database, build_dict, config_profile):
+  build_cpv_dict = {}
+  cpv_dict = {}
+  cpv_list = "1"
+  settings = portage.config(clone=portage.settings)
+  portdb = portage.portdbapi(mysettings=settings)
+  porttree = portage.portagetree(settings=settings)
+  trees = {"/" : {"porttree":porttree}}
+  dep_keys = ("DEPEND", "RDEPEND", "PDEPEND")
+  pkgdir = os.path.join(settings['PORTDIR'], build_dict['categories'] + "/" + build_dict['package'])
+  ebuild_version_checksum_tree = portage.checksum.sha256hash(pkgdir+ "/" + build_dict['package'] + "-" + build_dict['ebuild_version'] + ".ebuild")[0]
+  print ebuild_version_checksum_tree
+  if ebuild_version_checksum_tree != build_dict['ebuild_checksum']:
+    new_queue_id = database.check_revision(build_dict, config_profile, ebuild_version_checksum_tree)
+    if new_queue_id is None:
+      return None
+      if check_fail_times(build_dict['queue_id'], "cpv_checksum") is False:
+	update_fail_times(build_dict['queue_id'], "cpv_checksum")
+      else:
+	add_cpv_fail(build_dict['queue_id'], "cpv_checksum")
+      return None
+    build_dict = database.get_package_to_build(config_profile, new_queue_id)
+  categories = build_dict['categories']
+  package = build_dict['package']
+  ebuild_version = build_dict['ebuild_version']
+  ebuild_version_useflags = build_dict['build_useflags']
+  build_massage = build_dict['post_message']
+  cpv = unicode(categories + "/" + package + "-" + ebuild_version)
+  cp =  unicode(categories + "/" + package)
+  pkgdir = os.path.join(settings['PORTDIR'], build_dict['categories'] + "/" + build_dict['package'])
+  settings['O'] = pkgdir
+  print portage.getmaskingstatus(cpv, settings=settings, portdb=portdb)
+  if portage.getmaskingstatus(cpv, settings=settings, portdb=portdb) != []:
+    if check_fail_times(build_dict['queue_id'], "cpv_mask") is False:
+      update_fail_times(build_dict['queue_id'], "cpv_mask")
+    else:
+      add_cpv_fail(build_dict['queue_id'], "cpv_mask")
+      return None
+  build_use_flags_list = comper_useflags(settings, portdb, cpv, build_dict)
+  if check_file_in_manifest(pkgdir, settings, portdb, cpv, build_dict, build_use_flags_list) is False:
+    if check_fail_times(build_dict['queue_id'], "cpv_file_manifest") is False:
+      update_fail_times(build_dict['queue_id'], "cpv_file_manifest")
+    else:
+      add_cpv_fail(build_dict['queue_id'], "cpv_file_manifest")
+      return None
+  build_cpv_dict = get_needed_dep_useflags(cpv, build_use_flags_list)
+  print build_cpv_dict, build_use_flags_list, cpv
+  build_use_flags_dict = {}
+  if build_use_flags_list is None:
+    build_use_flags_dict['None'] = None
+  if build_cpv_dict is None:
+    build_cpv_dict = {}
+    build_cpv_dict[cpv] = build_use_flags_dict
+  else:
+    build_cpv_dict[cpv] = build_use_flags_dict
+  print build_cpv_dict
+  return build_cpv_dict
+  
+def main_loop(database, config_profile):
+  repeat = True
+  queue_id_list = 4
+  while repeat:
+    build_cpv_dict = {}
+    build_dict = {}
+    if check_configure(database, config_profile) is not True:
+      # time.sleep(60)
+     continue		# retunr to the start of the function
+    else:
+      build_dict = database.get_package_to_build(config_profile, queue_id_list)
+      print build_dict['ebuild_id'], build_dict['post_message']
+      if build_dict['ebuild_id'] is None:
+	if build_dict['post_message'] is None:
+	# time.sleep(60)
+	  print "build_dict none"
+	  queue_id_list = queue_id_list + 1
+	  print queue_id_list
+	  continue 		# return to the start of the function
+      build_cpv_dict = get_cpv_build_list(database, build_dict, config_profile)
+      if build_cpv_dict is None:
+	queue_id_list = queue_id_list + 1
+	continue		# return to the start of the function
+      build_cpv_list = []
+      for k, v in build_cpv_dict.iteritems():
+	build_use_flags_list = []
+	for x, y in v.iteritems():
+	  if y is True:
+	    build_use_flags_list.append(x)
+	  if y is False:
+	    build_use_flags_list.append("-" + x)
+	print k, build_use_flags_list
+	if build_use_flags_list == []:
+	  build_cpv_list.append("=" + k)
+	else:
+	  build_use_flags = ""
+	  for flags in build_use_flags_list:
+	    build_use_flags = build_use_flags + flags + ","
+	  build_cpv_list.append("=" + k + "[" + build_use_flags + "]")
+	print build_cpv_list
+      argscmd = []
+      argscmd.append("--buildpkg")
+      argscmd.append("--usepkg")
+      argscmd.append("--oneshot")
+      for build_cpv in build_cpv_list:
+	argscmd.append(build_cpv)
+      print argscmd
+      emerge_main(args=argscmd)
+      sys.exit()
+      queue_id_list = queue_id_list + 1
+      
 def main():
   # Main
   get_conf_settings.__init__						# Init settings from the configfile
   database = init_sql_backend()						# Init the Database
-  input_atom = ""
-  if check_make_conf(database) is True:
-    build_list = database.get_package_to_build(get_conf_settings.SetBuildConfig)
-    print build_list
-    categories = build_list[0]
-    package = build_list[1]
-    ebuild_version = build_list[2]
-    ebuild_version_useflags = build_list[3]
-    ebuild_version_checksum_db = build_list[4]
-    use_final_checksum_db = build_list[5]
-    cpv = categories + "/" + package + "-" + ebuild_version
-    cp =  categories + "/" + package
-    settings = portage.config(clone=portage.settings)
-    portdb = portage.portdbapi(mysettings=settings)
-    porttree = portage.portagetree(settings=settings)
-    trees = {"/" : {"porttree":porttree}}
-    dep_keys = ("DEPEND", "RDEPEND", "PDEPEND")
-    pkgdir = os.path.join(settings['PORTDIR'], categories + "/" + package)
-    print pkgdir
-    print settings['DISTDIR']
-    settings['O'] = pkgdir
-    if portage.portdb.cpv_exists(cpv) is 1:
-      print cpv
-    ebuild_fetchmap = portdb.getFetchMap(cpv, useflags=None, mytree=None)
-    print ebuild_fetchmap
-    myfetchlistdict = portage.FetchlistDict(pkgdir, settings, portdb)
-    my_manifest = portage.Manifest(pkgdir, settings['DISTDIR'], fetchlist_dict=myfetchlistdict, manifest1_compat=False, from_scratch=False)
-    check_file_in_manifest = my_manifest.findFile(package + "-" + ebuild_version + ".ebuild")
-    if not check_file_in_manifest is None:
-      print "works"
-    ebuild_version_checksum_tree = portage.checksum.sha256hash(pkgdir+ "/" + package + "-" + ebuild_version + ".ebuild")
-    print ebuild_version_checksum_tree[0]
-    print ebuild_version_checksum_db
-    if ebuild_version_checksum_tree[0] == ebuild_version_checksum_db[0]:
-      print "checksum ok"
-    try:
-      ebuild_auxdb_list = portdb.aux_get(cpv, portage.auxdbkeys)
-    except:
-      ebuild_auxdb_list = []
-    if not ebuild_auxdb_list is []:
-      print ebuild_auxdb_list
-    iuse_flags, final_use = get_flags(settings, portage.portdb, cpv)
-    use_list = ""
-      # Fix the use flags so we can hash it
-    for i in final_use:
-      use_list = use_list + i + " "
-    use_final_checksum_tree = hashlib.md5(use_list).hexdigest()
-    print use_final_checksum_db
-    if use_final_checksum_tree == use_final_checksum_db:
-      print ebuild_version_useflags
-    ebuild_fetchmap = portdb.getFetchMap(cpv, useflags=use_list, mytree=None)
-    print ebuild_fetchmap
-    settings.unlock()
-    portage.fetch(ebuild_fetchmap, settings, listonly=0, fetchonly=0, locks_in_subdir='.locks', use_locks=1, try_mirrors=1)
-    settings.lock()
-    print my_manifest.checkCpvHashes(cpv, checkDistfiles=True, onlyDistfiles=False, checkMiscfiles=True)
-    print portdb.fetch_check(cpv, useflags=use_list, mysettings=settings, all=False)
-    if portage.getmaskingstatus(cpv, settings=settings, portdb=portdb) == []:
-      print "works no mask"
-    metadata = dict(zip(dep_keys, portdb.aux_get(cpv, dep_keys)))
-    dep_str = " ".join(metadata[k] for k in dep_keys)
-    success, atoms = portage.dep_check(dep_str, None, settings, use="yes", trees=trees, myroot=settings["ROOT"])
-    if not success:
-      sys.stderr.write("%s %s\n" % (cpv, atoms))
-    else:
-      bad_atoms = []
-      for atom in atoms:
-	if not atom.blocker and atom.cp == input_atom.cp:
-	  matches = portdb.xmatch("match-all", atom)
-	  if not portage.dep.match_from_list(input_atom, matches):
-	    bad_atoms.append(atom)
-	if bad_atoms:
-	  sys.stdout.write("%s\t%s\n" % (cpv, " ".join(bad_atoms)))
+  config_profile = get_conf_settings.SetBuildConfig
+  main_loop(database, config_profile)
 
 if __name__ == "__main__":
   main()

diff --git a/buildhost/buildhost/sqlbackend.py b/buildhost/buildhost/sqlbackend.py
index bb4166f..a609be1 100644
--- a/buildhost/buildhost/sqlbackend.py
+++ b/buildhost/buildhost/sqlbackend.py
@@ -21,12 +21,12 @@ class DatabaseConfig(object):
   # The  user needs:
   # DELETE, INSERT, UPDATE, SELECT
   # Do NOT change these, set the values in the config file /etc/buildhost/buildhost.conf
-  settings['sql_mysql'] = {}
-  settings['sql_mysql']['charset'] = 'utf8'
-  settings['sql_mysql']['host'] = get_conf_settings.SetSqlHost
-  settings['sql_mysql']['db'] = get_conf_settings.SetSqlDB
-  settings['sql_mysql']['user'] = get_conf_settings.SetSqlUser
-  settings['sql_mysql']['passwd'] = get_conf_settings.SetSqlPasswd
+  settings['sql_pgsql'] = {}
+  # settings['sql_pgsql']['charset'] = 'utf8'
+  settings['sql_pgsql']['host'] = get_conf_settings.SetSqlHost
+  settings['sql_pgsql']['database'] = get_conf_settings.SetSqlDB
+  settings['sql_pgsql']['user'] = get_conf_settings.SetSqlUser
+  settings['sql_pgsql']['password'] = get_conf_settings.SetSqlPasswd
     
 class SQLPackageDatabase(object):
   """we have to store our stuff somewhere
@@ -42,87 +42,605 @@ class SQLPackageDatabase(object):
 
   sql = {}
 
-  sql['SELECT_make_conf_checksum_db'] = """
-    SELECT make_conf_checksum
-    FROM configs
-    WHERE config = %s
-    """
-  def get_make_conf_checksum_db(self, config_line):
-    sql = self.sql['SELECT_make_conf_checksum_db']
-    self.cursor.execute(sql, (config_line))
-    entries = self.cursor.fetchone()
+  def get_default_config(self, config_profile):
+    cursor = self.conn.cursor()
+    sqlQ = "SELECT make_conf_checksum FROM configs WHERE active = 'True' AND id = %s AND updateing = 'False'"
+    cursor.execute(sqlQ, (config_profile,))
+    return cursor.fetchone()
+  
+  def get_package_to_build(self, config_profile, queue_id):
+    cursor = self.conn.cursor()
+    print queue_id, config_profile
+    # get what to build
+    sqlQ1 = "SELECT ebuild_id, post_message FROM buildqueue WHERE config = %s AND extract(epoch from (NOW()) - timestamp) > 7200 AND queue_id = %s"
+    # get use flags to use
+    sqlQ2 = "SELECT useflag, enabled FROM ebuildqueuedwithuses WHERE queue_id = %s"
+    # get ebuild version (v) and package id
+    sqlQ3 = 'SELECT ebuild_version, package_id, ebuild_checksum FROM ebuilds WHERE id = %s'
+    # get categoriy and package (c, p)
+    sqlQ4 ='SELECT category, package_name FROM packages WHERE package_id = %s'
+    build_dict = {}
+    build_useflags_dict = {}
+    cursor.execute(sqlQ1, (config_profile, queue_id))
+    entries = cursor.fetchone()
+    print entries
     if entries is None:
-      return None
+      build_dict['ebuild_id'] = None
+      build_dict['post_message'] = None
+      return build_dict
+    build_dict['queue_id'] = queue_id
+    ebuild_id = entries[0]
+    build_dict['ebuild_id'] = ebuild_id
+    build_dict['post_message'] = entries[1]
+    cursor.execute(sqlQ2, (queue_id,))
+    entries = cursor.fetchall()
+    if entries == []:
+      build_useflags = None
+    else:
+      build_useflags = entries
+    cursor.execute(sqlQ3, (ebuild_id,))
+    entries = cursor.fetchall()[0]
+    build_dict['ebuild_version'] = entries[0]
+    build_dict['package_id'] = entries[1]
+    build_dict['ebuild_checksum'] = entries[2]
+    cursor.execute(sqlQ4, (entries[1],))
+    entries = cursor.fetchall()[0]
+    build_dict['categories'] = entries[0]
+    build_dict['package'] = entries[1]
+    if build_useflags is None:
+      build_dict['build_useflags'] = None
     else:
-      return entries
+      for x in build_useflags:
+	build_useflags_dict[x[0]] = x[1]
+	build_dict['build_useflags'] = build_useflags_dict
+    print "build_dict", build_dict
+    return build_dict
+
+  def check_revision(self, build_dict, config_profile, ebuild_version_checksum_tree):
+    cursor = self.conn.cursor()
+    sqlQ1 = 'SELECT id FROM ebuilds WHERE ebuild_version = %s AND ebuild_checksum = %s AND package_id = %s'
+    sqlQ2 = 'SELECT queue_id FROM buildqueue WHERE ebuild_id = %s AND config = %s'
+    sqlQ3 = "SELECT useflag FROM ebuildqueuedwithuses WHERE queue_id = %s AND enabled = 'True'"
+    cursor.execute(sqlQ1, (build_dict['ebuild_version'], ebuild_version_checksum_tree, build_dict['package_id']))
+    ebuild_id = cursor.fetchone()[0]
+    print ebuild_id
+    if ebuild_id is None:
+      return None
+    cursor.execute(sqlQ2, (ebuild_id, config_profile))
+    queue_id_list = cursor.fetchall()
+    if queue_id_list is None:
+      return None
+    for queue_id in queue_id_list:
+      cursor.execute(sqlQ3, (queue_id,))
+      entries = cursor.fetchall()
+      if entries == []:
+	build_useflags = None
+      else:
+	build_useflags = entries
+      print build_useflags, build_dict['build_useflags']
+      if build_useflags is build_dict['build_useflags']:
+	print queue_id[0]
+	return queue_id[0]
+    return None
+
+  def get_config_list_all(self):
+    cursor = self.conn.cursor()
+    sqlQ = 'SELECT id FROM configs'
+    cursor.execute(sqlQ)
+    return cursor.fetchall()
+
+  def update__make_conf(self, configsDict):
+    cursor = self.conn.cursor()
+    
+    sqlQ = 'UPDATE configs SET make_conf_checksum = %s, make_conf_text = %s, active = %s, config_error = %s WHERE id = %s'
+    for k, v in configsDict.iteritems():
+      params = [v['make_conf_checksum_tree'], v['make_conf_text'], v['active'], v['config_error'], k]
+      cursor.execute(sqlQ, params)
+    self.conn.commit()
+
+  def have_package_db(self, categories, package):
+    cursor = self.conn.cursor()
+    sqlQ ='SELECT package_id FROM packages WHERE category = %s AND package_name = %s'
+    params = categories, package
+    cursor.execute(sqlQ, params)
+    return cursor.fetchone()
+
+  def get_categories_db(self):
+    cursor = self.conn.cursor()
+    sqlQ =' SELECT category FROM categories'
+    cursor.execute(sqlQ)
+    return cursor.fetchall()
+
+  def get_categories_checksum_db(self, categories):
+    cursor = self.conn.cursor()
+    sqlQ =' SELECT metadata_xml_checksum FROM categories_meta WHERE category = %s'
+    cursor.execute(sqlQ, (categories,))
+    return cursor.fetchone()
+
+  def add_new_categories_meta_sql(self, categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree):
+    cursor = self.conn.cursor()
+    sqlQ = 'INSERT INTO categories_meta (category, metadata_xml_checksum, metadata_xml_text) VALUES  ( %s, %s, %s )'
+    params = categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree
+    cursor.execute(sqlQ, params)
+    self.conn.commit()
+
+  def update_categories_meta_sql(self, categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree):
+    cursor = self.conn.cursor()
+    sqlQ ='UPDATE categories_meta SET metadata_xml_checksum = %s, metadata_xml_text = %s WHERE category = %s'
+    params = (categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree, categories)
+    cursor.execute(sqlQ, params)
+    self.conn.commit()
+
+  def add_new_manifest_sql(self, package_id, get_manifest_text, manifest_checksum_tree):
+    cursor = self.conn.cursor()
+    sqlQ = 'INSERT INTO manifest (package_id, manifest, checksum) VALUES  ( %s, %s, %s )'
+    params = package_id, get_manifest_text, manifest_checksum_tree
+    cursor.execute(sqlQ, params)
+    self.conn.commit()
+
+  def add_new_package_metadata(self, package_id, package_metadataDict):
+    cursor = self.conn.cursor()
+    sqlQ = 'SELECT changelog_checksum FROM packages_meta WHERE package_id = %s'
+    cursor.execute(sqlQ, (package_id,))
+    if cursor.fetchone() is None:
+      sqlQ = 'INSERT INTO packages_meta (package_id, changelog_text, changelog_checksum, metadata_text, metadata_checksum) VALUES  ( %s, %s, %s, %s, %s )'
+      for k, v in package_metadataDict.iteritems():
+	params = package_id, v['changelog_text'], v['changelog_checksum'], v[' metadata_xml_text'], v['metadata_xml_checksum']
+	cursor.execute(sqlQ, params)
+      self.conn.commit()
+
+  def update_new_package_metadata(self, package_id, package_metadataDict):
+    cursor = self.conn.cursor()
+    sqlQ = 'SELECT changelog_checksum, metadata_checksum FROM packages_meta WHERE package_id = %s'
+    cursor.execute(sqlQ, package_id)
+    entries = cursor.fetchone()
+    changelog_checksum_db = entries[0]
+    metadata_checksum_db = entries[1]
+    for k, v in package_metadataDict.iteritems():
+      if changelog_checksum_db != v['changelog_checksum']:
+	sqlQ = 'UPDATE packages_meta SET changelog_text = %s, changelog_checksum = %s WHERE package_id = %s'
+	params = v['changelog_text'], v['changelog_checksum'], package_id
+	cursor.execute(sqlQ, params)
+      if metadata_checksum_db != v['metadata_xml_checksum']:
+	sqlQ = 'UPDATE packages_meta SET metadata_text = %s, metadata_checksum = %s WHERE package_id = %s'
+	params = v[' metadata_xml_text'], v['metadata_xml_checksum'], package_id
+	cursor.execute(sqlQ, params)
+    self.conn.commit()
+
+  def get_manifest_db(self, package_id):
+    cursor = self.conn.cursor()
+    sqlQ = 'SELECT checksum FROM manifest WHERE package_id = %s'
+    cursor.execute(sqlQ, package_id)
+    return cursor.fetchone()
+
+  def update_manifest_sql(self, package_id, get_manifest_text, manifest_checksum_tree):
+   cursor = self.conn.cursor()
+   sqlQ = 'UPDATE manifest SET checksum = %s, manifest = %s WHERE package_id = %s'
+   params = (manifest_checksum_tree, get_manifest_text, package_id)
+   cursor.execute(sqlQ, params)
+   self.conn.commit()
 
-  sql['SELECT_config_active'] = """
-    SELECT make_conf_checksum
-    FROM configs
-    WHERE config = %s AND active = 'y' AND updateing = 'n'
+  def add_new_metadata(self, metadataDict):
+    for k, v in metadataDict.iteritems():
+      cursor = self.conn.cursor()
+      sqlQ = 'SELECT updaterestrictions( %s, %s )'
+      params = k, v['restrictions']
+      cursor.execute(sqlQ, params)
+      sqlQ = 'SELECT updatekeywords( %s, %s )'
+      params = k, v['keyword']
+      cursor.execute(sqlQ, params)
+      sqlQ = 'SELECT updateiuse( %s, %s )'
+      params = k, v['iuse']
+      cursor.execute(sqlQ, params)
+    self.conn.commit()
+
+  def add_new_package_sql(self, packageDict):
+    #lets have a new cursor for each metod as per best practice
+    cursor = self.conn.cursor()
+    sqlQ="SELECT insert_ebuild( %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'True')"
+    ebuild_id_list = []
+    package_id_list = []
+    for k, v in packageDict.iteritems():
+      params = [v['categories'], v['package'], v['ebuild_version_tree'], v['ebuild_version_revision'], v['ebuild_version_checksum_tree'],
+      v['ebuild_version_text'], v['ebuild_version_metadata_tree'][0], v['ebuild_version_metadata_tree'][1],
+      v['ebuild_version_metadata_tree'][12], v['ebuild_version_metadata_tree'][2], v['ebuild_version_metadata_tree'][3],
+      v['ebuild_version_metadata_tree'][5],v['ebuild_version_metadata_tree'][6], v['ebuild_version_metadata_tree'][7],
+      v['ebuild_version_metadata_tree'][9], v['ebuild_version_metadata_tree'][11],
+      v['ebuild_version_metadata_tree'][13],v['ebuild_version_metadata_tree'][14], v['ebuild_version_metadata_tree'][15],
+      v['ebuild_version_metadata_tree'][16]]
+      cursor.execute(sqlQ, params)
+      mid = cursor.fetchone()
+      mid=mid[0]
+      ebuild_id_list.append(mid[1])
+      package_id_list.append(mid[0])
+    self.conn.commit()
+    # add_new_metadata(metadataDict)
+    return ebuild_id_list, package_id_list
+
+  def add_new_ebuild_sql(packageDict, new_ebuild_list):
+    #lets have a new cursor for each metod as per best practice
+    cursor = self.conn.cursor()
+    sqlQ="SELECT insert_ebuild( %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'True')"
+    ebuild_id_list = []
+    package_id_list = []
+    for k, v in packageDict.iteritems():
+      for x in new_ebuild_list:
+	if x == v['ebuild_version_tree']:
+	  params = [v['categories'], v['package'], v['ebuild_version_tree'], v['ebuild_version_revision'], v['ebuild_version_checksum_tree'],
+	  v['ebuild_version_text'], v['ebuild_version_metadata_tree'][0], v['ebuild_version_metadata_tree'][1],
+	  v['ebuild_version_metadata_tree'][12], v['ebuild_version_metadata_tree'][2], v['ebuild_version_metadata_tree'][3],
+	  v['ebuild_version_metadata_tree'][5],v['ebuild_version_metadata_tree'][6], v['ebuild_version_metadata_tree'][7],
+	  v['ebuild_version_metadata_tree'][9], v['ebuild_version_metadata_tree'][11],
+	  v['ebuild_version_metadata_tree'][13],v['ebuild_version_metadata_tree'][14], v['ebuild_version_metadata_tree'][15],
+	  v['ebuild_version_metadata_tree'][16]]
+	  cursor.execute(sqlQ, params)
+	  mid = cursor.fetchone()
+	  mid=mid[0]
+	  ebuild_id_list.append(mid[1])
+	  package_id_list.append(mid[0])
+    self.conn.commit()
+    # add_new_metadata(metadataDict)
+    return ebuild_id_list, package_id_list
+
+  def update_active_ebuild(self, package_id, ebuild_version_tree):
+    cursor = self.conn.cursor()
+    sqlQ ="UPDATE ebuilds SET active = 'False', timestamp = now() WHERE package_id = %s AND ebuild_version = %s AND active = 'True'"
+    cursor.execute(sqlQ, (package_id, ebuild_version_tree))
+    self.conn.commit()
+
+  sql['SELECT_get_ebuild_id_db'] = """
+    SELECT id
+    FROM packages
+    WHERE category = %s AND ebuild_name = %s AND ebuild_version = %s
     """
-  def get_config_active(self, config_line):
-    sql = self.sql['SELECT_config_active']
-    self.cursor.execute(sql, (config_line))
+  def get_ebuild_id_db(self, categories, package, ebuild_version_tree):
+    sql = self.sql['SELECT_get_ebuild_id_db']
+    self.cursor.execute(sql, (categories, package, ebuild_version_tree))
     entries = self.cursor.fetchone()
-    if entries is None:
-      return None
-    else:
-      return True
-  sql['SELECT_package_build'] = """
-    SELECT categories, package, ebuild_version, use_flags, ebuild_version_checksum, use_checksum
-    FROM buildqueru
-    WHERE config = %s
-    ORDER BY index2
-    LIMIT 1
-    """
-  def get_package_to_build(self, config_line):
-    sql = self.sql['SELECT_package_build']
-    self.cursor.execute(sql, config_line)
+    return entries
+
+  sql['SELECT_get_cpv_from_ebuild_id'] = """
+    SELECT category, ebuild_name, ebuild_version
+    FROM packages
+    WHERE id = %s
+    """
+  def get_cpv_from_ebuild_id(self, ebuild_id):
+    cursor = self.conn.cursor()
+    sqlQ = 'SELECT package_id FROM ebuild WHERE id = %s'
+    self.cursor.execute(sql, ebuild_id)
     entries = self.cursor.fetchone()
-    if entries is None:
-      return False
-    else:
-      return entries
+    return entries
+
+  def get_cp_from_package_id(self, package_id):
+    cursor = self.conn.cursor()
+    sqlQ = "SELECT ARRAY_TO_STRING(ARRAY[category, package_name] , '/') AS cp FROM packages WHERE package_id = %s"
+    cursor.execute(sqlQ, (package_id,))
+    return cursor.fetchone()
+
+  sql['SELECT_get_keyword_id_db'] = """
+    SELECT id_keyword
+    FROM keywords
+    WHERE ARCH = %s AND stable = %s
+    """
+  def get_keyword_id_db(self, arch, stable):
+    sql = self.sql['SELECT_get_keyword_id_db']
+    self.cursor.execute(sql, (arch, stable))
+    entries = self.cursor.fetchone()
+    return entries
+
+  sql['INSERT_add_new_keywords'] = """
+    INSERT INTO keywordsToEbuild
+    (ebuild_id, id_keyword)
+    VALUES  ( %s, %s )
+    """
+  def add_new_keywords(self, ebuild_id, keyword_id):
+      sql = self.sql['INSERT_add_new_keywords']
+      self.cursor.execute(sql, (ebuild_id, keyword_id))
+      self.db.commit()
     
+  sql['SELECT_have_package_buildqueue'] = """
+    SELECT useflags
+    FROM buildqueue
+    WHERE  ebuild_id = %s  AND config_id = %s
+    """
+  def have_package_buildqueue(self, ebuild_id, config_id):
+    sql = self.sql['SELECT_have_package_buildqueue']
+    params = (ebuild_id[0], config_id)
+    self.cursor.execute(sql, params)
+    entries = self.cursor.fetchone()
+    return entries
+  
+  def add_new_package_buildqueue(self, ebuild_id, config_id, iuse_flags_list, use_enable, message):
+    cursor = self.conn.cursor()
+    sqlQ="SELECT insert_buildqueue( %s, %s, %s, %s, %s )"
+    if not iuse_flags_list:
+      iuse_flags_list=None
+      use_enable=None
+    params = ebuild_id, unicode(config_id), iuse_flags_list, use_enable, message
+    cursor.execute(sqlQ, params)
+    self.conn.commit()
+   
+  sql['SELECT_get_package_id'] = """
+    SELECT package_id
+    FROM packages
+    WHERE category = %s AND package_name = %s
+    """
   sql['SELECT_get_ebuild_checksum'] = """
     SELECT ebuild_checksum
     FROM ebuild
-    WHERE categories = %s AND package = %s AND ebuild_version = %s
+    WHERE package_id = %s AND ebuild_version = %s
     """
-  def get_ebuild_checksum(self, categories, package, ebuild_version_tree):
-    sql = self.sql['SELECT_get_ebuild_checksum']
-    self.cursor.execute(sql, (categories, package, ebuild_version_tree))
-    entries = self.cursor.fetchone()
+  def get_ebuild_checksum(self, package_id, ebuild_version_tree):
+    cursor = self.conn.cursor()
+    sqlQ = 'SELECT ebuild_checksum FROM ebuilds WHERE package_id = %s AND ebuild_version = %s AND active = TRUE'
+    cursor.execute(sqlQ, (package_id, ebuild_version_tree))
+    entries = cursor.fetchone()
     if entries is None:
       return None
-    else:
-      return entries
+    return entries[0]
+  
+  sql['UPDATE_update_ebuild_db'] = """
+    UPDATE packages
+    SET ebuild_checksum = %s, ebuild_text = %s,
+    depend = %s, rdepend = %s, pdepend = %s, slot = %s, src_url = %s, homepage = %s, license = %s,
+    description = %s, keywords = %s, inherited = %s, iuse = %s, required_use = %s, provide = %s,
+    eapi = %s, properties = %s, defined_phases = %s
+    WHERE ebuild_id = %s
+    """
+  def update_ebuild_sql(self, ebuild_id, ebuild_version_checksum_tree,
+      ebuild_version_metadata_tree, ebuild_version_text):
+    sql = self.sql['UPDATE_update_ebuild_db']
+    params = (ebuild_version_checksum_tree[0],
+      ebuild_version_text, ebuild_version_metadata_tree[0], ebuild_version_metadata_tree[1],
+      ebuild_version_metadata_tree[12], ebuild_version_metadata_tree[2], ebuild_version_metadata_tree[3],
+      ebuild_version_metadata_tree[5], ebuild_version_metadata_tree[6], ebuild_version_metadata_tree[7],
+      ebuild_version_metadata_tree[9], ebuild_version_metadata_tree[10], ebuild_version_metadata_tree[11],
+      ebuild_version_metadata_tree[13], ebuild_version_metadata_tree[14], ebuild_version_metadata_tree[15],
+      ebuild_version_metadata_tree[16], ebuild_id)
+    self.cursor.execute(sql, params)
+    self.db.commit()
+  
+  sql['SELECT_cp_all_db'] = """
+    SELECT CONCAT_WS('/',categories, package)
+    FROM package
+    WHERE active = '1'
+    """
+  def cp_all_db(self):
+    cursor = self.conn.cursor()
+    sqlQ = "SELECT package_id FROM packages"
+    cursor.execute(sqlQ)
+    return cursor.fetchall()
+
+  def add_old_package(self, old_package_list):
+    cursor = self.conn.cursor()
+    mark_old_list = []
+    sqlQ = "UPDATE ebuilds SET active = 'FALSE', timestamp = NOW() WHERE package_id = %s AND active = 'TRUE' RETURNING package_id"
+    for old_package in old_package_list:
+      cursor.execute(sqlQ, (old_package[0],))
+      entries = cursor.fetchone()
+      if entries is not None:
+	mark_old_list.append(entries[0])
+    self.conn.commit()
+    return mark_old_list
+  
+  sql['UPDATE_add_old_categories'] = """
+    UPDATE categories
+    SET active = '0'
+    WHERE categories = %s
+    """
+  def get_old_categories(self, categories_line):
+    cursor = self.conn.cursor()
+    sqlQ = "SELECT package_name FROM packages WHERE category = %s"
+    cursor.execute(sqlQ (categories_line))
+    return cursor.fetchone()
+
+  def del_old_categories(self, real_old_categoriess):
+    cursor = self.conn.cursor()
+    sqlQ = 'DELETE FROM categories categories_meta WHERE category = %s'
+    cursor.execute(sqlQ (real_old_categories))
+    self.conn.commit()
+
+  def add_old_ebuild(self, package_id, old_ebuild_list):
+    cursor = self.conn.cursor()
+    sqlQ1 = "UPDATE ebuilds SET active = 'FALSE' WHERE package_id = %s AND ebuild_version = %s"
+    sqlQ2 = "SELECT id FROM ebuilds WHERE package_id = %s AND ebuild_version = %s AND active = 'TRUE'"
+    sqlQ3 = "SELECT queue_id FROM buildqueue WHERE ebuild_id = %s"
+    sqlQ4 = 'DELETE FROM ebuildqueuedwithuses buildqueue WHERE queue_id = %s'
+    for old_ebuild in  old_ebuild_list:
+      cursor.execute(sqlQ2, (package_id, old_ebuild[0]))
+      ebuild_id_list = cursor.fetchall()
+      if ebuild_id_list is not None:
+	for ebuild_id in ebuild_id_list:
+	  cursor.execute(sqlQ3, (ebuild_id))
+	  queue_id_list = cursor.fetchall()
+	  if queue_id_list is not None:
+	    for queue_id in queue_id_list:
+	      cursor.execute(sqlQ4, (queue_id))
+      cursor.execute(sqlQ1, (package_id, old_ebuild[0]))
+    self.conn.commit()
+    
+  sql['SELECT_cp_all_old_db'] = """
+    SELECT CONCAT_WS('/',categories, package)
+    FROM package
+    WHERE active = '0' AND DATEDIFF(NOW(), timestamp) > 60
+    """
+  def cp_all_old_db(self, old_package_id_list):
+    cursor = self.conn.cursor()
+    old_package_list = []
+    for old_package in old_package_id_list:
+      sqlQ = "SELECT package_id FROM ebuilds WHERE package_id = %s AND active = 'FALSE' AND date_part('days', NOW() - timestamp) < 60"
+      cursor.execute(sqlQ, old_package)
+      entries = cursor.fetchone()
+      if entries is None:
+	old_package_list.append(old_package)
+    return old_package_list
+  
+  sql['DELETE_del_old_ebuild'] = """
+    DELETE FROM ebuild
+    WHERE categories = %s AND package = %s AND active = '0' AND DATEDIFF(NOW(), timestamp) > 60
+    """
+  def del_old_ebuild(self, ebuild_old_list_db):
+    cursor = self.conn.cursor()
+    sqlQ1 ='SELECT id FROM ebuilds WHERE ebuild_version = %s'
+    sqlQ2 = 'SELECT build_id FROM buildlog WHERE ebuild_id = %s'
+    sqlQ3 = 'DELETE FROM qa_problems repoman_problems ebuildbuildwithuses WHERE build_id = %s'
+    sqlQ4 = 'DELETE FROM ebuildhaveskeywords ebuildhavesiuses ebuildhavesrestrictions buildlog WHERE ebuild_id = %s'
+    for ebuild_version in ebuild_old_list_db:
+      cursor.execute(sqlQ1, (ebuild_version))
+      ebuild_id_list = cursor.fetchall()
+      for ebuild_id in ebuild_id_list:
+	cursor.execute(sqlQ2, ebuild_id)
+	build_id_list = cursor.fetchall()
+	for build_id in build_id_list:
+	  cursor.execute(sqlQ3, build_id)
+	cursor.execute(sqlQ4, ebuild_id)
+    self.conn.commit()
+  
+  sql['DELETE_del_old_package'] = """
+    DELETE FROM package
+    WHERE categories = %s AND package = %s AND active = '0' AND DATEDIFF(NOW(), timestamp) > 60
+    """
+  def del_old_package(self, package_id_list):
+    cursor = self.conn.cursor()
+    sqlQ1 = 'SELECT id FROM ebuilds WHERE package_id = %s'
+    sqlQ2 = 'SELECT build_id FROM buildlog WHERE ebuild_id = %s'
+    sqlQ3 = 'DELETE FROM qa_problems, repoman_problems, ebuildbuildwithuses WHERE build_id = %s'
+    sqlQ4 = 'DELETE FROM ebuildhaveskeywords, ebuildhavesiuses, ebuildhavesrestrictions, buildlog WHERE ebuild_id = %s'
+    sqlQ5 = 'DELETE FROM ebuilds, manifest, package_meta, packages WHERE package_id = %s'
+    for package_id in package_id_list:
+      cursor.execute(sqlQ1, package_id)
+      ebuild_id_list = cursor.fetchall()
+      for ebuild_id in ebuild_id_list:
+	cursor.execute(sqlQ2, ebuild_id)
+	build_id_list = cursor.fetchall()
+	for build_id in build_id_list:
+	  cursor.execute(sqlQ3, build_id)
+	cursor.execute(sqlQ4, ebuild_id)
+      cursor.execute(sqlQ5, package_id)
+    self.conn.commit()
+
+  sql['DELETE_del_old_categories'] = """
+    DELETE FROM categories
+    WHERE categories = %s AND active = '0' AND DATEDIFF(NOW(), timestamp) > 60
+    """
+  def del_old_package(self, categories):
+    sql = self.sql['DELETE_del_old_categories']
+    self.cursor.execute(sql, (categories))
+    self.db.commit()
+
+  def cp_list_db(self, package_id):
+    cursor = self.conn.cursor()
+    sqlQ = "SELECT ebuild_version FROM ebuilds WHERE active = 'TRUE' AND package_id = %s"
+    cursor.execute(sqlQ, (package_id))
+    return cursor.fetchall()
+
+  def cp_list_old_db(self, package_id):
+    cursor = self.conn.cursor()
+    sqlQ ="SELECT id, ebuild_version FROM ebuilds WHERE active = 'FALSE' AND package_id = %s AND date_part('days', NOW() - timestamp) > 60"
+    cursor.execute(sqlQ, package_id)
+    return cursor.fetchall()
+
+  def add_qa_repoman(self, ebuild_id_list, qa_error, packageDict, config_id):
+    ebuild_i = 0
+    cursor = self.conn.cursor()
+    for k, v in packageDict.iteritems():
+      ebuild_id = ebuild_id_list[ebuild_i]
+      sqlQ = 'INSERT INTO buildlog (ebuild_id, config, error_summary, timestamp ) VALUES  ( %s, %s, %s, now() ) RETURNING build_id'
+      if v['ebuild_error'] != [] or qa_error != []:
+	if v['ebuild_error'] != [] or qa_error == []:
+	  summary = "Repoman"
+	elif v['ebuild_error'] == [] or qa_error != []:
+	  summary = "QA"
+	else:
+	  summary = "QA:Repoman"
+	params = (ebuild_id, config_id, summary)
+	cursor.execute(sqlQ, params)
+	build_id = cursor.fetchone()
+	if v['ebuild_error'] != []:
+	  sqlQ = 'INSERT INTO repoman_problems (problem, build_id ) VALUES ( %s, %s )'
+	  for x in v['ebuild_error']:
+	    params = (x, build_id)
+	    cursor.execute(sqlQ, params)
+	if qa_error != []:
+	  sqlQ = 'INSERT INTO qa_problems (problem, build_id ) VALUES ( %s, %s )'
+	  for x in qa_error:
+	    params = (x, build_id)
+	    cursor.execute(sqlQ, params)
+      ebuild_i = ebuild_i +1
+    self.conn.commit()
+
+  sql['SELECT_qa_repoman'] = """
+    SELECT categories, package, ebuild_version, qa, repoman, config, hosts
+    FROM buildlog
+    WHERE ebuild = %sAND build = '' AND config_id = %s
+    """
+  def get_qa_repoman(self, ebuild_id, config_id):
+	sql = self.sql['SELECT_qa_repoman']
+	params = (ebuild_id, config_id)
+	self.cursor.execute(sql, params)
+	entries = self.cursor.fetchall()
+	return entries
   
-  def commit(self):
-    """Run the commit function for the database store"""
+  sql['DELETE_del_qa_repoman'] = """
+    DELETE FROM buildlog
+    WHERE ebuild_id AND build = '' AND config_id = %s
+    """
+  def del_qa_repoman(self, ebuild_id, config_id):
+    sql = self.sql['DELETE_del_qa_repoman']
+    self.cursor.execute(sql, (ebuild_id, config_id))
     self.db.commit()
 
-class MySQLPackageDB(SQLPackageDatabase):
+  sql['UPDATE_update_qa_repoman'] = """
+    UPDATE buildlog
+    SET qa = %s, repoman = %s
+    WHERE ebuild_id = %s AND build = '' AND config_id = %s
+    """
+  def update_qa_repoman(self, ebuild_id, qa_error, repoman_error, config_id):
+    sql = self.sql['UPDATE_update_qa_repoman']
+    self.cursor.execute(sql, (qa_error, repoman_error, ebuild_id, config_id))
+    self.db.commit()
+
+  def get_arch_db(self):
+    cursor = self.conn.cursor()
+    sqlQ = 'SELECT keyword FROM keywords WHERE keyword = %s'
+    cursor.execute(sqlQ, ('ppc',))
+    return cursor.fetchone()
+  
+  def add_new_arch_db(self, arch_list):
+    cursor = self.conn.cursor()
+    sqlQ = 'INSERT INTO keywords (keyword) VALUES  ( %s )'
+    for arch in arch_list:
+      cursor.execute(sqlQ, (arch,))
+    self.conn.commit()
+
+  sql['INSERT_add_new_restriction_db'] = """
+      INSERT INTO ebuildHavesRestrictions
+      (ebuild_id, restriction)
+      VALUES  ( %s, %s )
+    """
+
+  def closeconnection(self):
+    self.conn.close()
+
+class PgSQLPackageDB(SQLPackageDatabase):
     """override for MySQL backend"""
 
     syntax_placeholder = "%s"
-    syntax_autoincrement = 'AUTO_INCREMENT'
-
+    
     def __init__(self, config=None):
         # Do not complain about correct usage of ** magic
         # pylint: disable-msg=W0142
         SQLPackageDatabase.__init__(self)
 
-        if config is None or 'db' not in config:
+        if config is None or 'database' not in config:
             print "No configuration available!"
             sys.exit(1)
 
         try:
-            import MySQLdb
+            import psycopg2
         except ImportError:
-            print "Please install a recent version of MySQLdb for Python"
+            print "Please install a recent version of dev-python/psycopg for Python"
             sys.exit(1)
 
-        self.db = MySQLdb.connect(**config)
-        self.cursor = self.db.cursor()
+        self.conn = psycopg2.connect(**config)
+