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

[Magnus Granberg]

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

alot of bug fixing

---
 buildhost/updatedb/core.py       |  412 ++++++++++++++++-----------------
 buildhost/updatedb/sqlbackend.py |  481 ++++++++++++++++----------------------
 2 files changed, 393 insertions(+), 500 deletions(-)

diff --git a/buildhost/updatedb/core.py b/buildhost/updatedb/core.py
index 49968c7..34be0e7 100644
--- a/buildhost/updatedb/core.py
+++ b/buildhost/updatedb/core.py
@@ -100,6 +100,7 @@ def  get_ebuild_text(filename):
   return text, cvs_revision
 
 def check_make_conf(database):
+  # FIXME: mark any config updating true in the db when updating the configs
   # Get the config list
   config_list_all = database.get_config_list_all()
   print "Checking configs for changes and errors"
@@ -108,7 +109,7 @@ def check_make_conf(database):
     attDict={}
     # Set the config dir
     check_config_dir = get_conf_settings.SetBuildhostRoot + "config/" + config_id[0] + "/"
-    make_conf_file = check_config_dir + "etc/make.conf"
+    make_conf_file = check_config_dir + "etc/portage/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)
@@ -128,13 +129,12 @@ def check_make_conf(database):
       attDict['active'] = 'True'
       print "Pass", config_id[0]
     # Get the checksum of make.conf
-    make_conf_checksum_tree = portage.checksum.sha256hash(make_conf_file)
+    make_conf_checksum_tree = portage.checksum.sha256hash(make_conf_file)[0]
     # Check if we have change the make.conf and update the db with it
     attDict['make_conf_text'] = get_file_text(make_conf_file)
-    attDict['make_conf_checksum_tree'] = portage.checksum.sha256hash(make_conf_file)[0]
+    attDict['make_conf_checksum_tree'] = make_conf_checksum_tree
     configsDict[config_id]=attDict
   database.update__make_conf(configsDict)
-  # database.closeconnection()
   print "Updated configurtions"
 
 def init_portage_settings(database):
@@ -299,18 +299,19 @@ def config_match_ebuild(database, categories, package):
     latest_ebuild = ""
     latest_ebuild_version = unicode("")
     # Check if could get cpv from portage
+    # and get the lastes ebuild on that config
     if ebuild_match_list != []:
       for ebuild_match_line in ebuild_match_list:
 	latest_ebuild = ebuild_match_line
       # Get the version of cpv
       latest_ebuild_version = portage.versions.cpv_getversion(latest_ebuild)
-      # Get the iuse and use flags for that config in config_line
+      # Get the iuse and use flags for that config
       iuse_flags_list, final_use_list = get_flags(settings2, portdb2, latest_ebuild)
       iuse_flags_list2 = []
       for iuse_line in iuse_flags_list:
 	iuse_flags_list2.append(reduce_flag(iuse_line))
+      # Dic the needed info
       attDict = {}
-      # Fix the use flags so we can hash it
       attDict = {}
       attDict['ebuild_version'] = latest_ebuild_version
       attDict['useflags'] = final_use_list
@@ -318,24 +319,30 @@ def config_match_ebuild(database, categories, package):
       attDict['package'] = package
       attDict['categories'] = categories
       config_cpv_listDict[config_id] = attDict
+    # Clean some cache
     portdb2.close_caches()
     portage.portdbapi.portdbapi_instances.remove(portdb2)
   return config_cpv_listDict
 		
 def add_new_ebuild_buildquery_db(database, ebuild_id_list, packageDict, config_cpv_listDict):
+  # Get the needed info from packageDict and config_cpv_listDict and put that in buildqueue
+  # Only add it if ebuild_version in packageDict and config_cpv_listDict match
   if config_cpv_listDict != {}:
     message = None
+    # Unpack config_cpv_listDict
     for k, v in config_cpv_listDict.iteritems():
       config_id = k
       latest_ebuild_version = v['ebuild_version']
       iuse_flags_list = list(set(v['iuse']))
       use_enable= v['useflags']
       use_disable = list(set(iuse_flags_list).difference(set(use_enable)))
+      # Make a dict with enable and disable use flags for ebuildqueuedwithuses
       use_flagsDict = {}
       for x in use_enable:
 	use_flagsDict[x] = True
       for x in use_disable:
 	use_flagsDict[x] = False
+      # Unpack packageDict
       i = 0
       for k, v in packageDict.iteritems():
 	ebuild_id = ebuild_id_list[i]
@@ -344,6 +351,7 @@ def add_new_ebuild_buildquery_db(database, ebuild_id_list, packageDict, config_c
 	for u, s in  use_flagsDict.iteritems():
 	  use_flags_list.append(u)
 	  use_enable_list.append(s)
+	# Comper ebuild_version and add the ebuild_version to buildqueue
 	if portage.vercmp(v['ebuild_version_tree'], latest_ebuild_version) == 0:
 	  database.add_new_package_buildqueue(ebuild_id, config_id, use_flags_list, use_enable_list, message)
 	  print "B",  config_id, v['categories'] + "/" + v['package'] + "-" + latest_ebuild_version, "USE:", use_enable	# B = Build config cpv use-flags
@@ -466,11 +474,10 @@ def digestcheck(mysettings, pkgdir):
 	return 1
 
 def check_repoman(settings, portdb, database, categories, package, ebuild_version_tree, config_id):
-  # We run repoman run_checks
+  # We run repoman run_checks on the ebuild
   pkgdir = settings['PORTDIR'] + "/" + categories + "/" + package
   full_path = pkgdir + "/" + package + "-" + ebuild_version_tree + ".ebuild"
   cpv = categories + "/" + package + "-" + ebuild_version_tree
-  default_config_root = get_conf_settings.SetBuildhostRoot +"config/" + config_id + "/"
   root = '/'
   trees = {
   root : {'porttree' : portage.portagetree(root, settings=settings)}
@@ -495,81 +502,35 @@ def check_repoman(settings, portdb, database, categories, package, ebuild_versio
   except UnicodeDecodeError:
     # A file.UTF8 failure will have already been recorded above.
     pass
+  # fails will have a list with repoman errors
   return fails
-  
-def add_new_keywords_restriction(ebuild_id, ebuild_line):
-  ebuild_keywords = portdb.aux_get(ebuild_line, ["KEYWORDS"])[0].split()
-  if not ebuild_keywords == []:
-    for keyword in ebuild_keywords:
-      if keyword.startswith("~"):
-	element = keyword.split('~')
-	arch = element[1]
-	stable = "~"
-      elif keyword.startswith("-"):
-	element = keyword.split('-')
-	arch = element[1]
-	stable = "-"
-      else:
-	arch = keyword
-	stable = ""
-      keyword_id = database.get_keyword_id_db(arch, stable)
-      database.add_new_keywords(ebuild_id[0], keyword_id[0])
-    # restrictions
-    ebuild_restrictions = portdb.aux_get(ebuild_line, ["RESTRICT"])[0].split()
-    if not ebuild_restrictions is []:
-      for restriction in ebuild_restrictions:
-	database.add_new_restriction_db(ebuild_id[0], restriction)
-
-def update_qa_repoman(ebuild_id, qa_error, repoman_error, config_id):
-  qa_repoman_list = database.get_qa_repoman(ebuild_id, config_id)
-  if qa_repoman_list == ():
-    return
-  if qa_error == "" and repoman_error == "":
-    database.del_qa_repoman(ebuild_id, config_id)
-  else:
-    database.update_qa_repoman(ebuild_id, qa_error, repoman_error, config_id)
 
-def add_new_package_db(settings, portdb, database, categories, package):
-  # add new categories package ebuild to tables package and ebuilds
-  print "N", categories + "/" + package				# N = New Package
-  pkgdir = settings['PORTDIR'] + "/" + categories + "/" + package		# Get PORTDIR + cp
-  categories_dir = settings['PORTDIR'] + "/" + categories + "/"
-  # Get the ebuild list for cp
-  ebuild_list_tree = portdb.cp_list((categories + "/" + package), use_cache=1, mytree=None)
-  config_cpv_listDict = config_match_ebuild(database, categories, package)
-  config_id  = database.get_default_config()
-  packageDict ={}
-  for ebuild_line in sorted(ebuild_list_tree):
-    attDict = {}
-    # split out ebuild version
-    ebuild_version_tree = portage.versions.cpv_getversion(ebuild_line)
-    # Get the checksum of the ebuild
-    ebuild_version_checksum_tree = portage.checksum.sha256hash(pkgdir + "/" + package + "-" + ebuild_version_tree + ".ebuild")[0]
-    # Get the auxdbkeys infos for the ebuild
-    ebuild_version_metadata_tree = get_ebuild_metadata(portdb, ebuild_line)
-    if ebuild_version_metadata_tree  == []:
-	  ebuild_version_metadata_tree = ['','','','','','','','','','','','','','','','','','','','','','','','','']
-	  ebuild_version_checksum_tree = ['0']
-    # Get the ebuild contents
-    ebuild_version_text = get_ebuild_text(pkgdir + "/" + package + "-" + ebuild_version_tree + ".ebuild")
-    repoman_error = check_repoman(settings, portdb, database, categories, package, ebuild_version_tree, config_id[0])
-    # add the ebuild to the table packages
-    attDict['categories'] = categories
-    attDict['package'] = package
-    attDict['ebuild_version_tree'] = ebuild_version_tree
-    attDict['ebuild_version_checksum_tree']= ebuild_version_checksum_tree
-    attDict['ebuild_version_metadata_tree'] = ebuild_version_metadata_tree
-    attDict['ebuild_version_text'] = ebuild_version_text[0]
-    attDict['ebuild_version_revision'] = ebuild_version_text[1]
-    attDict['ebuild_error'] = repoman_error
-    packageDict[ebuild_line] = attDict
-  return_id = database.add_new_package_sql(packageDict)
-  ebuild_id_list = return_id[0]
-  package_id_list = return_id[1]
-  package_id = package_id_list[0]
-  manifest_checksum_tree = portage.checksum.sha256hash(pkgdir + "/Manifest")[0]
-  get_manifest_text = get_file_text(pkgdir + "/Manifest")
-  database.add_new_manifest_sql(package_id, get_manifest_text, manifest_checksum_tree)
+def get_packageDict(pkgdir, ebuild_line, settings, portdb, database, categories, package, config_id):
+  attDict = {}
+  ebuild_version_tree = portage.versions.cpv_getversion(ebuild_line)
+  ebuild_version_checksum_tree = portage.checksum.sha256hash(pkgdir + "/" + package + "-" + ebuild_version_tree + ".ebuild")[0]
+  ebuild_version_text = get_ebuild_text(pkgdir + "/" + package + "-" + ebuild_version_tree + ".ebuild")
+  repoman_error = check_repoman(settings, portdb, database, categories, package, ebuild_version_tree, config_id)
+  ebuild_version_metadata_tree = get_ebuild_metadata(portdb, ebuild_line)
+  # if there some error to get the metadata we add rubish to the 
+  # ebuild_version_metadata_tree and set ebuild_version_checksum_tree to 0
+  # so it can be updated next time we update the db
+  if ebuild_version_metadata_tree  == []:
+    ebuild_version_metadata_tree = ['','','','','','','','','','','','','','','','','','','','','','','','','']
+    ebuild_version_checksum_tree = ['0']
+  # add the ebuild to the dict packages
+  attDict['categories'] = categories
+  attDict['package'] = package
+  attDict['ebuild_version_tree'] = ebuild_version_tree
+  attDict['ebuild_version_checksum_tree']= ebuild_version_checksum_tree
+  attDict['ebuild_version_metadata_tree'] = ebuild_version_metadata_tree
+  attDict['ebuild_version_text'] = ebuild_version_text[0]
+  attDict['ebuild_version_revision'] = ebuild_version_text[1]
+  attDict['ebuild_error'] = repoman_error
+  return attDict
+
+def get_metadataDict(packageDict, ebuild_id_list):
+  # Make the metadataDict from packageDict
   ebuild_i = 0
   metadataDict ={}
   for k, v in packageDict.iteritems():
@@ -588,15 +549,10 @@ def add_new_package_db(settings, portdb, database, categories, package):
     attDict['iuse'] =  metadata_iuse
     metadataDict[ebuild_id_list[ebuild_i]] = attDict
     ebuild_i = ebuild_i +1
-  database.add_new_metadata(metadataDict)
-  qa_error = []
-  if not digestcheck(settings, pkgdir):
-    qa_error.append("Manifest: Error in manifest file.")
-    print "QA:", categories + "/" + package, qa_error
-  database.add_qa_repoman(ebuild_id_list, qa_error, packageDict, config_id[0])
-  # Add the ebuild to the buildqueru table if needed
-  add_new_ebuild_buildquery_db(database, ebuild_id_list, packageDict, config_cpv_listDict)
-  # Get some checksum on some files
+  return metadataDict
+
+def get_package_metadataDict(pkgdir, package):
+  # Make package_metadataDict
   attDict = {}
   package_metadataDict = {}
   changelog_checksum_tree = portage.checksum.sha256hash(pkgdir + "/ChangeLog")
@@ -608,87 +564,49 @@ def add_new_package_db(settings, portdb, database, categories, package):
   attDict['metadata_xml_checksum'] =  metadata_xml_checksum_tree[0]
   attDict[' metadata_xml_text'] =  metadata_xml_text_tree
   package_metadataDict[package] = attDict
-  database.add_new_package_metadata(package_id, package_metadataDict)
-
-def update_package_db(settings, portdb, database, categories, package, package_id):
-  # Update the categories and package with new info
-  pkgdir = settings['PORTDIR'] + "/" + categories + "/" + package		# Get PORTDIR with cp
-  # Get the checksum from the file in portage tree
-  manifest_checksum_tree = portage.checksum.sha256hash(pkgdir + "/Manifest")
-  # Get the checksum from the db in package table
-  manifest_checksum_db = database.get_manifest_db(package_id)
-  # if we have the same checksum return else update the package
-  if manifest_checksum_tree[0] != manifest_checksum_db[0]:
-    print "U", categories + "/" + package		# U = Update
-    if not digestcheck(settings, pkgdir):
-      qa_error = "Manifest:"
-      print "QA:", categories + "/" + package, qa_error
-    else:
-      qa_error = ""
-    # Get some checksum on some files
-    # changelog_checksum_tree = portage.checksum.sha256hash(pkgdir + "/ChangeLog")
-    # metadata_xml_checksum_tree = portage.checksum.sha256hash(pkgdir + "/metadata.xml")
-    # Get text from ChangeLog and metadata.xml
-    # changelog_text = get_file_text(pkgdir + "/ChangeLog")
-    # metadata_xml_text = get_file_text(pkgdir + "/metadata.xml")
-    # update categories/package info to package table
-    database.update_package_sql(categories, package, manifest_checksum_tree)
-    ebuild_list_tree = portdb.cp_list((categories + "/" + package), use_cache=1, mytree=None)
-    config_cpv_list = config_match_ebuild(database, categories, package)
-    config_list_all = database.get_default_config()
-    cinfig_id = config_list_all[0]
-    for ebuild_line in ebuild_list_tree:
-      # split out ebuild version
-      ebuild_version_tree = portage.versions.cpv_getversion(ebuild_line)
-      # Get the checksum of the ebuild in tree
-      ebuild_version_checksum_tree = portage.checksum.sha256hash(pkgdir + "/" + package + "-" + ebuild_version_tree + ".ebuild")
-      # Get the checksum of the ebuild in db
-      ebuild_version_manifest_checksum_db = database.get_ebuild_checksum(categories, package, ebuild_version_tree)
-      sys.exit()
-      # check if the checksum have change on the ebuild
-      if ebuild_version_manifest_checksum_db is None or ebuild_version_checksum_tree[0] != ebuild_version_manifest_checksum_db[0]:
-	# Get the auxdbkeys infos for the ebuild
-	ebuild_version_metadata_tree = get_ebuild_metadata(portdb, ebuild_line)
-	if ebuild_version_metadata_tree  == []:
-	  ebuild_version_metadata_tree = ['','','','','','','','','','','','','','','','','','','','','','','','','']
-	  ebuild_version_checksum_tree = ['0','0']
-	# Get the ebuild contents
-	ebuild_version_text =  get_file_text(pkgdir +"/" + package + "-" + ebuild_version_tree + ".ebuild")
-	# check if the ebuild is new
-	repoman_error = check_repoman(settings, portdb, database, categories, package, ebuild_version_tree)
-	if ebuild_version_manifest_checksum_db is None:
-	  # add the ebuild to the ebuild tble
-	  database.add_new_ebuild_sql(categories, package, ebuild_version_tree, ebuild_version_checksum_tree,
-	    ebuild_version_metadata_tree, ebuild_version_text)
-	  ebuild_id = database.get_ebuild_id_db(categories, package, ebuild_version_tree)
-	  add_new_keywords_restriction(ebuild_id, ebuild_line)
-	  if not qa_error and repoman_error == "":
-	    database.add_qa_repoman(ebuild_id, qa_error, repoman_error, config_id)
-	  print "N", categories + "/" + package + "-" + ebuild_version_tree	# N = New ebuild
-	else:
-	   # update the ebuild to the ebuild table
-	  ebuild_id = database.get_ebuild_id_db(categories, package, ebuild_version_tree)
-	  database.update_ebuild_sql(ebuild_id, ebuild_version_checksum_tree, ebuild_version_metadata_tree, ebuild_version_text)
-	  del_keywords_restriction(ebuild_id, ebuild_line)
-	  add_new_keywords_restriction(ebuild_id, ebuild_line)
-	  update_qa_repoman(ebuild_id, qa_error, repoman_error, config_id)
-	  print "U", categories + "/" + package + "-" + ebuild_version_tree	# U = Updated ebuild
-	# Add the ebuild to the buildqueru table if needed
-	add_new_ebuild_buildquery_db(database, ebuild_id, ebuild_version_tree, config_cpv_list)
+  return package_metadataDict
 
-def update_categories_db(settings, database, categories):
+def add_new_package_db(settings, portdb, database, categories, package):
+  # add new categories package ebuild to tables package and ebuilds
+  print "N", categories + "/" + package				# N = New Package
+  pkgdir = settings['PORTDIR'] + "/" + categories + "/" + package		# Get PORTDIR + cp
   categories_dir = settings['PORTDIR'] + "/" + categories + "/"
-  categories_metadata_xml_checksum_db = database.have_categories_db(categories)
-  categories_metadata_xml_checksum_tree = portage.checksum.sha256hash(categories_dir + "metadata.xml")
-  if categories_metadata_xml_checksum_db != categories_metadata_xml_checksum_tree:
-    categories_metadata_xml_text_tree = get_file_text(categories_dir + "metadata.xml")
-    database.update_categories_sql(categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree)
-
-def mark_old_ebuild_db(portdb, database, categories, package):
-  # Get ebuild list on categories, package in the tree
+  # Get the ebuild list for cp
   ebuild_list_tree = portdb.cp_list((categories + "/" + package), use_cache=1, mytree=None)
+  config_cpv_listDict = config_match_ebuild(database, categories, package)
+  config_id  = database.get_default_config()[0]
+  packageDict ={}
+  for ebuild_line in sorted(ebuild_list_tree):
+    # Make the needed packageDict
+    packageDict[ebuild_line] = get_packageDict(pkgdir, ebuild_line, settings, portdb, database, categories, package, config_id)
+  # Add the ebuild to db
+  return_id = database.add_new_package_sql(packageDict)
+  ebuild_id_list = return_id[0]
+  package_id_list = return_id[1]
+  package_id = package_id_list[0]
+  # Add the manifest file to db
+  manifest_checksum_tree = portage.checksum.sha256hash(pkgdir + "/Manifest")[0]
+  get_manifest_text = get_file_text(pkgdir + "/Manifest")
+  database.add_new_manifest_sql(package_id, get_manifest_text, manifest_checksum_tree)
+  # Add metadataDict to db
+  metadataDict = get_metadataDict(packageDict, ebuild_id_list)
+  database.add_new_metadata(metadataDict)
+  # Add any qa and repoman erro for the ebuild to buildlog
+  qa_error = []
+  if not digestcheck(settings, pkgdir):
+    qa_error.append("Manifest: Error in manifest file.")
+    print "QA:", categories + "/" + package, qa_error
+  database.add_qa_repoman(ebuild_id_list, qa_error, packageDict, config_id)
+  # Add the ebuild to the buildqueru table if needed
+  add_new_ebuild_buildquery_db(database, ebuild_id_list, packageDict, config_cpv_listDict)
+  # Add some checksum on some files
+  package_metadataDict = get_package_metadataDict(pkgdir, package)
+  database.add_new_package_metadata(package_id, package_metadataDict)
+  return package_id
+
+def mark_old_ebuild_db(portdb, database, categories, package, package_id, ebuild_list_tree):
   # Get ebuild list on categories, package in the db
-  ebuild_list_db = database.cp_list_db(categories, package)
+  ebuild_list_db = database.cp_list_db(package_id)
   # Check if don't have the ebuild in the tree
   # Add it to the no active list
   old_ebuild_list = []
@@ -699,67 +617,129 @@ def mark_old_ebuild_db(portdb, database, categories, package):
     # Set no active on ebuilds in the db that no longer in tree
     if  old_ebuild_list != []:
       for old_ebuild in  old_ebuild_list:
-	# database.add_old_ebuild(categories, package, old_ebuild)
 	print "O", categories + "/" + package + "-" + old_ebuild[0]
+      database.add_old_ebuild(package_id, old_ebuild_list)
   # Check if we have older no activ ebuilds then 60 days
-  ebuild_old_list_db = database.cp_list_old_db(categories, package)
+  ebuild_old_list_db = database.cp_list_old_db(package_id)
   # Delete older ebuilds in the db
-  if ebuild_old_list_db != ():
+  if ebuild_old_list_db != []:
     for del_ebuild_old in ebuild_old_list_db:
-      print "D", categories + "/" + package + "-" + del_ebuild_old[0]
-    # database.del_old_ebuild(categories, package)
+      print "D", categories + "/" + package + "-" + del_ebuild_old[1]
+    database.del_old_ebuild(ebuild_old_list_db)
 
-def mark_old_package_db(database, package_list_tree):
+def update_package_db(settings, portdb, database, categories, package, package_id):
+  # Update the categories and package with new info
+  pkgdir = settings['PORTDIR'] + "/" + categories + "/" + package		# Get PORTDIR with cp
+  # Get the checksum from the file in portage tree
+  manifest_checksum_tree = portage.checksum.sha256hash(pkgdir + "/Manifest")[0]
+  # Get the checksum from the db in package table
+  manifest_checksum_db = database.get_manifest_db(package_id)[0]
+  # if we have the same checksum return else update the package
+  ebuild_list_tree = portdb.cp_list((categories + "/" + package), use_cache=1, mytree=None)
+  if manifest_checksum_tree != manifest_checksum_db:
+    print "U", categories + "/" + package		# U = Update
+    # Get the text in Manifest and update it
+    get_manifest_text = get_file_text(pkgdir + "/Manifest")
+    database.update_manifest_sql(package_id, get_manifest_text, manifest_checksum_tree)
+    # Get package_metadataDict and update the db with it
+    package_metadataDict = get_package_metadataDict(pkgdir, package)
+    database.update_new_package_metadata(package_id, package_metadataDict)
+    # Get config_cpv_listDict
+    config_cpv_listDict = config_match_ebuild(database, categories, package)
+    config_id  = database.get_default_config()
+    packageDict ={}
+    for ebuild_line in sorted(ebuild_list_tree):
+      old_ebuild_list = []
+      # split out ebuild version
+      ebuild_version_tree = portage.versions.cpv_getversion(ebuild_line)
+      # Get the checksum of the ebuild in tree and db
+      ebuild_version_checksum_tree = portage.checksum.sha256hash(pkgdir + "/" + package + "-" + ebuild_version_tree + ".ebuild")[0]
+      ebuild_version_manifest_checksum_db = database.get_ebuild_checksum(package_id, ebuild_version_tree)
+      # Check if the checksum have change
+      if ebuild_version_manifest_checksum_db is None or ebuild_version_checksum_tree != ebuild_version_manifest_checksum_db:
+	# Get packageDict for ebuild
+	packageDict[ebuild_line] = get_packageDict(pkgdir, ebuild_line, settings, portdb, database, categories, package, config_id)
+	if ebuild_version_manifest_checksum_db is None:
+	  print "N", categories + "/" + package + "-" + ebuild_version_tree	# N = New ebuild
+	else:
+	  print "U", categories + "/" + package + "-" + ebuild_version_tree	# U = Updated ebuild
+	  # Fix so we can use add_new_package_sql(packageDict) to update the ebuilds
+	  old_ebuild_list.append(ebuild_version_tree)
+	  database.add_old_ebuild(package_id, old_ebuild_list)
+	  database.update_active_ebuild(package_id, ebuild_version_tree)
+    # Use packageDictand and metadataDict to update the db
+    return_id = database.add_new_package_sql(packageDict)
+    ebuild_id_list = return_id[0]
+    metadataDict = get_metadataDict(packageDict, ebuild_id_list)
+    database.add_new_metadata(metadataDict)
+    # Add any qa and repoman erros to buildlog
+    qa_error = []
+    if not digestcheck(settings, pkgdir):
+      qa_error.append("Manifest: Error in manifest file.")
+      print "QA:", categories + "/" + package, qa_error
+    database.add_qa_repoman(ebuild_id_list, qa_error, packageDict, config_id)
+    # Add the ebuild to the buildqueru table if needed
+    add_new_ebuild_buildquery_db(database, ebuild_id_list, packageDict, config_cpv_listDict)
+  # Mark or remove any old ebuilds
+  mark_old_ebuild_db(portdb, database, categories, package, package_id, sorted(ebuild_list_tree))
+
+def update_categories_db(settings, database, categories):
+  # Update categories_meta in the db
+  categories_dir = settings['PORTDIR'] + "/" + categories + "/"
+  categories_metadata_xml_checksum_tree = portage.checksum.sha256hash(categories_dir + "metadata.xml")[0]
+  categories_metadata_xml_text_tree = get_file_text(categories_dir + "metadata.xml")
+  categories_metadata_xml_checksum_db = database.get_categories_checksum_db(categories)
+  if categories_metadata_xml_checksum_db is None:
+    database.add_new_categories_meta_sql(categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree)
+  elif categories_metadata_xml_checksum_db != categories_metadata_xml_checksum_tree:
+    database.update_categories_meta_sql(categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree)
+
+def mark_old_package_db(database, package_id_list_tree):
   # Get categories/package list from db
   package_list_db = database.cp_all_db()
-  old_package_list = []
+  old_package_id_list = []
   # Check if don't have the categories/package in the tree
   # Add it to the no active list
   for package_line in package_list_db:
-    if not package_line[0] in package_list_tree:
-      old_package_list.append(package_line)
+    if not package_line in package_id_list_tree:
+      old_package_id_list.append(package_line)
   # Set no active on categories/package and ebuilds in the db that no longer in tree
-  if old_package_list != []:
-    for old_package in old_package_list:
-      element = old_package.split('/')
-      categories = element[0]
-      package = element[1]
-      database.add_old_package(categories, package)
-      print "O", categories + "/" + package
-  # Check if we have older no activ categories/package then 60 days
-  package_old_list_db = database.cp_all_old_db()
+  if old_package_id_list != []:
+    mark_old_list = database.add_old_package(old_package_id_list)
+    if mark_old_list != []:
+      for x in mark_old_list:
+	element = database.get_cp_from_package_id(x)
+	print "O", element[0]
+    # Check if we have older no activ categories/package then 60 days
+    del_package_id_old_list = database.cp_all_old_db(old_package_id_list)
   # Delete older  categories/package and ebuilds in the db
-  if package_old_list_db != ():
-    for real_old_package in package_old_list_db:
-      element = real_old_package[0].split('/')
-      categories = element[0]
-      package = element[1]
-      database.del_old_package(categories, package)
-      print "D", categories + "/" + package
+  if del_package_id_old_list != []:
+    for i in del_package_id_old_list:
+	element = database.get_cp_from_package_id(i)
+	print "D", element
+    database.del_old_package(del_package_id_old_list)
 
 def mark_old_categories_db(settings, database):
+  # Get categories list from the tree and db
   categories_list_tree = settings.categories
-  categories_list_db_active = database.get_categories_db("1")
-  old_categories_list = []
+  categories_list_db = database.get_categories_db()
+  categories_old_list = []
   # Check if don't have the categories in the tree
   # Add it to the no active list
-  for categories_line in categories_list_db_active:
+  for categories_line in categories_list_db:
     if not categories_line[0] in categories_list_tree:
-      old_categories_list.append(categories_line)
-  # Set no active on categories in the db that no longer in tree
-  if old_categories_list != []:
-    for old_categories in old_categories_list:
-      # database.add_old_categories(old_categories)
-      print "O", old_categories
-  # Check if we have older no activ categories then 60 days
-  categories_old_list_db = database.get_categories_db("0")
+      old_c = database.get_old_categories(categories_line[0])
+      if old_c is not None:
+	categories_old_list.append(categories_line)
   # Delete older  categories in the db
-  if categories_old_list_db != ():
-    for real_old_categories in categories_old_list_db:
-      # database.del_old_categories(real_old_categoriess, package)
+  if categories_old_list != []:
+    for real_old_categories in categories_old_list:
+      database.del_old_categories(real_old_categoriess)
       print "D", real_old_categories
  
 def update_arch_db(database):
+  # FIXME: check for new keyword
+  # Add arch db (keywords)
   if database.get_arch_db() is None:
     arch_list =  portage.archlist
     for arch in arch_list:
@@ -770,12 +750,13 @@ def update_arch_db(database):
 
 def update_package_list(settings, portdb, database):
   print "Checking categories, package, ebuilds"
+  package_id_list_tree = []
   # Will run some update checks and update package if needed
   # Get categories/package list from portage
   package_list_tree = portdb.cp_all()
   # Run the update package for all package in the list
   for package_line in sorted(package_list_tree):
-    # spliet the cp to categories and package
+    # split the cp to categories and package
     element = package_line.split('/')
     categories = element[0]
     package = element[1]
@@ -784,17 +765,18 @@ def update_package_list(settings, portdb, database):
     package_id = database.have_package_db(categories, package)
     if package_id is None:
       # Add new package with ebuilds
-      add_new_package_db(settings, portdb, database, categories, package)
+      package_id = add_new_package_db(settings, portdb, database, categories, package)
+      package_id_list_tree.append(package_id)
       # Ceck if we have the cp in the package table
     elif package_id is not None:
       # Update the packages with ebuilds
       update_package_db(settings, portdb, database, categories, package, package_id)
-    #mark_old_ebuild_db(portdb, database, categories, package)
-    #if (database.have_categories_db(categories)) is not None:
-      #update_categories_db(settings, database, categories)
-  #mark_old_package_db(database, package_list_tree)
-  #mark_old_categories_db(settings, database)
-  print "Checking categories, categories, ebuilds done"
+      package_id_list_tree.append(package_id)
+    update_categories_db(settings, database, categories)
+  # Remove any old package and categories
+  mark_old_package_db(database, sorted(package_id_list_tree))
+  mark_old_categories_db(settings, database)
+  print "Checking categories, package and ebuilds done"
 
 def main():
   # Main
@@ -802,7 +784,7 @@ def main():
   database = init_sql_backend()						# Init the Database
   settings =  init_portage_settings(database)			# Init settings for the default config
   portdb = portage.portdbapi(mysettings=settings)		# Set portdb = portdbapi mysettings
-  update_arch_db(database)
+  update_arch_db(database)						# Update the arch db if needed
   update_package_list(settings, portdb, database)			# Update the package db
   
 if __name__ == "__main__":

diff --git a/buildhost/updatedb/sqlbackend.py b/buildhost/updatedb/sqlbackend.py
index 2e803b3..a7ba779 100644
--- a/buildhost/updatedb/sqlbackend.py
+++ b/buildhost/updatedb/sqlbackend.py
@@ -48,11 +48,6 @@ class SQLPackageDatabase(object):
     cursor.execute(sqlQ)
     return cursor.fetchone()
   
-  sql['SELECT_config_list'] = """
-    SELECT config_id
-    FROM configs
-    WHERE default_config = False AND active = True
-    """
   def get_config_list(self):
     cursor = self.conn.cursor()
     sqlQ = 'SELECT id FROM configs WHERE default_config = False AND active = True'
@@ -80,49 +75,31 @@ class SQLPackageDatabase(object):
     cursor.execute(sqlQ, params)
     return cursor.fetchone()
 
-  sql['SELECT_have_categories_db'] = """
-    SELECT category
-    FROM categories
-    WHERE category = %s
-    """
-  def have_categories_db(self, categories):
-    sql = self.sql['SELECT_have_categories_db']
-    self.cursor.execute(sql, categories)
-    entries = self.cursor.fetchone()
-    return entries
+  def get_categories_db(self):
+    cursor = self.conn.cursor()
+    sqlQ =' SELECT category FROM categories'
+    cursor.execute(sqlQ)
+    return cursor.fetchall()
 
-  sql['SELECT_get_categories_db'] = """
-    SELECT categories
-    FROM categories
-    WHERE active = %s
-    """
-  def get_categories_db(self, active):
-    sql = self.sql['SELECT_get_categories_db']
-    self.cursor.execute(sql, active)
-    entries = self.cursor.fetchall()
-    return entries
+  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()
 
-  sql['INSERT_add_new_categories_tree'] = """
-    INSERT INTO categories
-    (category)
-    VALUES  ( %s )
-    """
-  def add_new_categories_sql(self, categories):
-	sql = self.sql['INSERT_add_new_categories_tree']
-	params = (categories)
-	self.cursor.execute(sql, params)
-	self.db.commit()
-
-  sql['UPDATE_categories_tree'] = """
-    UPDATE categories
-    SET metadata_xml_checksum = %s, metadata_xml_text = %s
-    WHERE categories = %s
-    """
-  def update_categories_sql(self, categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree):
-	sql = self.sql['UPDATE_categories_tree']
-	params = (categories_metadata_xml_checksum_tree[0], categories_metadata_xml_text_tree, categories)
-	self.cursor.execute(sql, params)
-	self.db.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()
@@ -142,22 +119,36 @@ class SQLPackageDatabase(object):
 	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()
-    
-  sql['UPDATE_package_tree'] = """
-    UPDATE manifest
-    SET checksum = %s
-    WHERE category = %s AND ebuild_name = %s
-    """
-  def update_package_sql(self, categories, package, manifest_checksum_tree):
-   sql = self.sql['UPDATE_package_tree']
-   params = (manifest_checksum_tree[0], categories, package)
-   self.cursor.execute(sql, params)
-   self.db.commit()
+
+  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()
 
   def add_new_metadata(self, metadataDict):
     for k, v in metadataDict.iteritems():
@@ -187,7 +178,6 @@ class SQLPackageDatabase(object):
       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]]
-      print params
       cursor.execute(sqlQ, params)
       mid = cursor.fetchone()
       mid=mid[0]
@@ -197,62 +187,49 @@ class SQLPackageDatabase(object):
     # add_new_metadata(metadataDict)
     return ebuild_id_list, package_id_list
 
-  sql['SELECT_get_ebuild_id_db'] = """
-    SELECT id
-    FROM packages
-    WHERE category = %s AND ebuild_name = %s AND ebuild_version = %s
-    """
-  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()
-    return entries
+  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_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()
     return entries
-  
-  
-  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 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()
   
   def add_new_package_buildqueue(self, ebuild_id, config_id, iuse_flags_list, use_enable, message):
     cursor = self.conn.cursor()
@@ -263,158 +240,129 @@ class SQLPackageDatabase(object):
     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 package_id = %s AND ebuild_version = %s
-    """
-  def get_ebuild_checksum(self, categories, package, ebuild_version_tree):
-    sql = self.sql['SELECT_get_package_id']
-    self.cursor.execute(sql, (categories, package))
-    entries = self.cursor.fetchone()
-    print entries
+
+  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
-    sql = self.sql['SELECT_get_ebuild_checksum']
-    self.cursor.execute(sql, (entries, ebuild_version_tree))
-    entries = self.cursor.fetchone()
-    return entries
-  
-  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()
+    return entries[0]
+
+  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['SELECT_cp_all_db'] = """
-    SELECT CONCAT_WS('/',categories, package)
-    FROM package
-    WHERE active = '1'
-    """
+  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()
+
+  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
   def cp_all_db(self):
-    sql = self.sql['SELECT_cp_all_db']
-    self.cursor.execute(sql)
-    entries = self.cursor.fetchall()
-    return entries
-  
-  sql['UPDATE_add_old_package'] = """
-    UPDATE package
-    SET active = '0'
-    WHERE categories = %s AND package = %s
-    """
-  def add_old_package(self, categories, package):
-    sql = self.sql['UPDATE_add_old_package']
-    self.cursor.execute(sql, (categories, package))
-    self.db.commit()
-  
-  sql['UPDATE_add_old_categories'] = """
-    UPDATE categories
-    SET active = '0'
-    WHERE categories = %s
-    """
-  def add_old_categories(self, categories):
-    sql = self.sql['UPDATE_add_old_categories']
-    self.cursor.execute(sql, (categories))
-    self.db.commit()
-
-  sql['UPDATE_add_old_ebuild'] = """
-    UPDATE ebuild
-    SET active = '0'
-    WHERE categories = %s AND package = %s AND ebuild_version = %s
-    """
-  def add_old_ebuild(self, categories, package, old_ebuild):
-    sql = self.sql['UPDATE_add_old_ebuild']
-    self.cursor.execute(sql, (categories, package, old_ebuild[0]))
-    self.db.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):
-    sql = self.sql['SELECT_cp_all_old_db']
-    self.cursor.execute(sql)
-    entries = self.cursor.fetchall()
-    return entries
-  
-  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, categories, package):
-    sql = self.sql['DELETE_del_old_ebuild']
-    self.cursor.execute(sql, (categories, package))
-    self.db.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, categories, package):
-    sql = self.sql['DELETE_del_old_package']
-    self.cursor.execute(sql, (categories, package))
-    self.db.commit()
-    del_old_ebuild(categories, package)
-
-  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()
-
-  sql['SELECT_cp_list_db'] = """
-    SELECT ebuild_version
-    FROM ebuild
-    WHERE active = '1' AND categories = %s AND package = %s
-    """
-  def cp_list_db(self, categories, package):
-    sql = self.sql['SELECT_cp_list_db']
-    self.cursor.execute(sql, (categories, package))
-    entries = self.cursor.fetchall()
-    return entries
-  
-  sql['SELECT_cp_list_old_db'] = """
-    SELECT ebuild_version
-    FROM ebuild
-    WHERE active = '0' AND categories = %s AND package = %s AND DATEDIFF(NOW(), timestamp) > 60
-    """
-  def cp_list_old_db(self, categories, package):
-    sql = self.sql['SELECT_cp_list_old_db']
-    self.cursor.execute(sql, (categories, package))
-    entries = self.cursor.fetchall()
-    return entries
+    cursor = self.conn.cursor()
+    sqlQ = "SELECT package_id FROM packages"
+    cursor.execute(sqlQ)
+    return cursor.fetchall()
+
+  def del_old_ebuild(self, ebuild_old_list_db):
+    cursor = self.conn.cursor()
+    sqlQ2 = 'SELECT build_id FROM buildlog WHERE ebuild_id = %s'
+    sqlQ3 = 'DELETE FROM qa_problems repoman_problems  WHERE build_id = %s'
+    sqlQ4 = 'DELETE FROM ebuildhaveskeywords ebuildhavesiuses WHERE ebuild_id = %s'
+    sqlQ5 = 'DELETE FROM ebuildbuildwithuses WHERE build_id = %s'
+    sqlQ6 = 'DELETE FROM ebuildhavesrestrictions buildlog WHERE ebuild_id = %s'
+    for del_ebuild_old in ebuild_old_list_db:
+      cursor.execute(sqlQ2, (del_ebuild_old[0],))
+      build_id_list = cursor.fetchall()
+      for build_id in build_id_list:
+	cursor.execute(sqlQ3, (build_id,))
+	cursor.execute(sqlQ5, (build_id,))
+      cursor.execute(sqlQ4, (del_ebuild_old[0],))
+      cursor.execute(sqlQ6, (del_ebuild_old[0],))
+    self.conn.commit()
+
+  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()
+
+  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 ) VALUES  ( %s, %s, %s ) RETURNING build_id'
+      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"
@@ -438,37 +386,6 @@ class SQLPackageDatabase(object):
       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
-  
-  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()
-
-  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'
@@ -482,12 +399,6 @@ class SQLPackageDatabase(object):
       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()